davetron5000-gliffy 0.1.7 → 0.2.0

data/lib/gliffy/request.rb

@@ -0,0 +1,101 @@
+require 'rubygems'
+require 'httparty'
+require 'logger'
+require 'gliffy/url'
+
+module Gliffy
+  # Handles making a request of the Gliffy server and all that that entails.
+  # This allows you to make requests using the "action" and the URL as
+  # described in the Gliffy documentation.  For example, if you wish 
+  # to get a user's folders, you could
+  #
+  #     request = Request.get('https://www.gliffy.com/api/1.0',credentials)
+  #     results = request.create('accounts/$account_id/users/$username/oauth_token.xml')
+  #     credentials.update_access_token(
+  #         results['response']['oauth_token_credentials']['oauth_token_secret'],
+  #         results['response']['oauth_token_credentials']['oauth_token'])
+  #     request.get('accounts/$account_id/users/$username/folders.xml')
+  #
+  # This will return a hash-referencable DOM objects, subbing the account id
+  # and username in when making the request (additionally, setting all needed
+  # parameters and signing the request).
+  class Request
+
+    attr_accessor :logger
+    # Modify the HTTP transport agent used.  This should
+    # have the same interface as HTTParty.
+    attr_accessor :http
+
+    # Create a new request object.
+    #
+    # [+api_root+] the root of where all API calls are made
+    # [+credentials+] a Credentials object with all the current credentials
+    # [+http+] This should implement the HTTParty interface
+    def initialize(api_root,credentials,http=HTTParty,logger=nil)
+      @api_root = api_root
+      @api_root += '/' if !(@api_root =~ /\/$/)
+      @credentials = credentials
+      @logger = logger || Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+      @http = http
+    end
+
+    # Implements getting a request and returning a response
+    # The implements methods that correspond to Gliffy's "action=" parameter.
+    # Based on this, it will know to do a GET or POST.  The method signature is
+    #
+    #     request.action_name(url,params)
+    # for example
+    #     request.get('accounts/$account_id.xml',:showUsers => true)
+    # note that you can use `$account_id` and `$username` in any URL and it 
+    # will be replaced accordingly.
+    #
+    # The return value is the return value from HTTParty, which is basically a hash
+    # that allows access to the returned DOM tree
+    def method_missing(symbol,*args)
+      if args.length >= 1
+        link_only = false
+        if symbol == :link_for
+          symbol = args.shift
+          link_only = true
+        end
+        @logger.debug("Executing a #{symbol} against gliffy for url #{args[0]}")
+
+        # exposing this for testing
+        protocol = determine_protocol(args[1])
+        @full_url_no_params = protocol + "://" + @api_root + replace_url(args[0])
+        url = SignedURL.new(@credentials,@full_url_no_params,symbol == :GET ? 'GET' : 'POST')
+        url.logger = @logger
+        url.params = args[1] if !args[1].nil?
+        url[:protocol_override] = nil
+        url[:action] = symbol
+
+        # These can be override for testing purposes
+        timestamp = args[2] if args[2]
+        nonce = args[3] if args[3]
+
+        full_url = url.full_url(timestamp,nonce)
+        if link_only
+          return full_url
+        else
+          response = @http.post(full_url)
+          return response
+        end
+      else
+        super(symbol,args)
+      end
+    end
+
+    def determine_protocol(params)
+      if params && params[:protocol_override]
+        params[:protocol_override].to_s
+      else
+        @credentials.default_protocol.to_s
+      end
+    end
+
+    def replace_url(url)
+      return url.gsub('$account_id',@credentials.account_id.to_s).gsub('$username',@credentials.username)
+    end
+  end
+end

data/lib/gliffy/response.rb

@@ -1,127 +1,284 @@
-require 'rexml/document'
-require 'array_has_response'
-require 'gliffy/rest'
-
-include REXML
+require 'gliffy/request'
 
 module Gliffy
-
-  # Base class for Gliffy response.  This class is also the entry point
-  # for parsing Gliffy XML:
-  #    
-  #     xml = get_xml_from_gliffy
-  #     response = self.from_xml(xml)
-  #     # response is now a Response or subclass of response
-  #     if response.success?
-  #       if response.not_modified?
-  #         # use the item(s) from your local cache
-  #       else
-  #         # it should be what you expect, e.g. Diagram, array of Users, etc.
-  #       end
-  #     else
-  #       puts response.message # in this case it's an Error
-  #     end
-  #
-  #
+  # Indicates no response at all was received.
+  class NoResponseException < Exception
+    def initialize(message)
+      super(message)
+    end
+  end
+  # Indicates that a response was received by that it wasn't
+  # parsable or readable as a Gliffy <response> 
+  class BadResponseException < Exception
+    def initialize(message)
+      super(message)
+    end
+  end
+  # Indicates that a valid Gliffy <response> was received and that it 
+  # indicated failure.  The message is the message sent by gliffy (if it was
+  # in the response)
+  class RequestFailedException < Exception
+    def initialize(message)
+      super(message)
+    end
+  end
+  # Base class for all response from gliffy
   class Response
-
-    # Creates a Response based on the XML passed in.
-    # The xml can be anything passable to REXML::Document.new, such as
-    # a Document, or a string containing XML
-    #
-    # This will return a Response, a subclass of Response, or an array of
-    # Response/subclass of Response objects.  In the case where an array is returned
-    # both success? and not_modified? may be called, so the idiom in the class Rdoc should
-    # be usable regardless of return value
-    def self.from_xml(xml)
-      raise ArgumentError.new("xml may not be null to #{to_s}.from_xml") if !xml
-      root = Document.new(xml).root
-      not_modified = root.attributes['not-modified'] == "true"
-      success = root.attributes['success'] == "true"
-
-      response = nil
-      if ! root.elements.empty?
-        klassname = to_classname(root.elements[1].name)
-        klass = Gliffy.const_get(klassname)
-        response = klass.from_xml(root.elements[1])
+    @@normal_error_callback = Proc.new do |response,exception|
+      if response
+        message = response.inspect
+        if response['response'] && response['response']['error']
+          http_status = response['response']['error']['http_status']
+          if http_status = "404"
+            message = "Not Found"
+          else
+            message = "HTTP Status #{http_status}"
+          end
+        end
+        raise exception.class.new(message)
       else
-        response = Response.new
+        raise exception 
       end
+    end
 
-      response.success = success
-      response.not_modified = not_modified
+    @@error_callback = @@normal_error_callback
 
-      response
+    # Factory for creating actual response subclasses.
+    # This takes the results of HTTParty's response, which is a hash, essentially.
+    # This assumes that any checks for validity have been done.
+    # [error_response] Set this to a Proc to handle errors if you don't want the default behavior.  The proc will get two arguments:
+    #                  [+response+] the raw response received (may be nil)
+    #                  [+exception+] One of NoResponseException, BadResponseException, or RequestFailedException.  The message of that exception is a usable message if you want to ignore the exception
+    def self.from_http_response(response,error_callback=nil)
+      verify(response,error_callback)
+      root = response['response']
+      klass = nil
+      root.keys.each do |key|
+        klassname = to_classname(key)
+        begin
+          this_klass = Gliffy.const_get(klassname)
+        rescue NameError
+          this_klass = nil
+        end
+        klass = this_klass unless this_klass.nil?
+      end
+      return Response.new(response.body) if !klass
+      return klass.from_http_response(root)
     end
 
-    # Returns true if the response represents a successful response
-    # false indicates failure and that element is most likely a Error
-    def success?; @success; end
-
-    # Returns true if this response indicates the requested resource
-    # was not modified, based on the headers provided with the request.
-    def not_modified?; @not_modified; end
+    # Verifies that the response represents success, calling
+    # the error callback if it doesn't
+    def self.verify(response,error_callback)
+      error_callback = @@error_callback if error_callback.nil?
+      return error_callback.call(response,NoResponseException.new('No response received at all')) if response.nil? 
+      return error_callback.call(response,BadResponseException.new('Not a Gliffy response')) if !response['response']
+      return error_callback.call(response,BadResponseException.new('No indication of success from Gliffy')) if !response['response']['success']
+      if response['response']['success'] != 'true'
+        error = response['response']['error']
+        return error_callback.call(response,RequestFailedException.new('Request failed but no error inside response')) if !error
+        return error_callback.call(response,RequestFailedException.new(error))
+      end
+    end
 
-    def success=(s); @success = s; end
-    def not_modified=(s); @not_modified = s; end
 
-    # Provides access to the rest implementation
-    attr_accessor :rest
+    attr_reader :body
 
-    protected
+    def initialize(params)
+      @params = params
+    end
 
-    def initialize
-      @success = true
-      @not_modified = false
+    # Implements access to the object information.
+    # Parameters should be typed appropriately.
+    # The names are those as defined by the Gliffy XSD, save for dashes
+    # are replaced with underscores.
+    def method_missing(symbol,*args)
+      if args.length == 0
+        @params[symbol]
+      else
+        super(symbol,args)
+      end
     end
 
-    # Converts a dash-delimited string to a camel-cased classname
+    private 
     def self.to_classname(name)
       classname = ""
-      name.split(/-/).each do |part|
+      name.split(/[-_]/).each do |part|
         classname += part.capitalize
       end
-      classname
+      classname + "Parser"
     end
   end
 
-  class ArrayResponseParser
-    def self.from_xml(element)
-      single_classname = self.to_s.gsub(/s$/,'').gsub(/Gliffy::/,'')
-      klass = Gliffy.const_get(single_classname)
-      list = Array.new
-      if (element)
-        element.each_element do |element|
-          list << klass.from_xml(element)
+  class ArrayParser # :nodoc:
+    def self.from_http_response(root,single_class,plural_name,single_name)
+      root = root[plural_name]
+      return nil if root.nil?
+      if root[single_name].kind_of?(Array)
+        list = Array.new
+        root[single_name].each do |item|
+          list << single_class.from_http_response(item)
         end
+        list
+      else
+        [single_class.from_http_response(root[single_name])]
       end
-      list
     end
   end
 
-  # An error from Gliffy
-  class Error < Response
-    # The HTTP status code that can help indicate the nature of the problem
-    attr_reader :http_status
-    # A description of the error that occured; not necessarily for human
-    # consumption
-    attr_reader :message
+  # Factory for parsing accounts
+  class AccountsParser # :nodoc:
+    def self.from_http_response(root)
+      return ArrayParser.from_http_response(root,AccountParser,'accounts','account')
+    end
+  end
 
-    def self.from_xml(element)
-      message = element.text
-      http_status = element.attributes['http-status'].to_i
-      Error.new(message,http_status)
+  # Factory for parsing folders
+  class FoldersParser # :nodoc:
+    def self.from_http_response(root)
+      return ArrayParser.from_http_response(root,FolderParser,'folders','folder')
     end
+  end
 
-    def initialize(message,http_status)
-      super()
-      @message = message
-      @http_status = http_status
+  # Factory for parsing versions
+  class VersionsParser # :nodoc:
+    def self.from_http_response(root)
+      return ArrayParser.from_http_response(root,VersionParser,'versions','version')
     end
+  end
 
-    def to_s
-      "#{@http_status}: #{@message}"
+  # Factory for parsing users
+  class UsersParser # :nodoc:
+    def self.from_http_response(root)
+      return ArrayParser.from_http_response(root,UserParser,'users','user')
     end
+  end
 
+  # Factory for parsing documents
+  class DocumentsParser # :nodoc:
+    def self.from_http_response(root)
+      return ArrayParser.from_http_response(root,DocumentParser,'documents','document')
+    end
   end
+
+  class BaseParser # :nodoc:
+    def self.from_http_response(root)
+      params = Hash.new
+      root.each do |key,value|
+        params[key.to_sym] = value
+      end
+      Response.new(params)
+    end
+
+    # Returns the item as an array, or nil if it was nil
+    def self.as_array(item)
+      if item.nil?
+        nil
+      else
+        [item].flatten
+      end
+    end
+
+    def self.add_int(root,name,new_name=nil)
+      if root[name]
+        root[new_name.nil? ? name : new_name] = root[name].to_i
+      end
+    end
+
+    def self.add_boolean(root,name)
+      root[name + "?"] = root[name] == 'true'
+    end
+
+    def self.add_date(root,name)
+      if root[name]
+        root[name] = Time.at(root[name].to_i / 1000) unless root[name].kind_of? Time
+      end
+    end
+  end
+
+  class FolderParser < BaseParser # :nodoc:
+    def self.from_http_response(root)
+      add_int(root,'id','folder_id')
+      add_boolean(root,'is_default')
+      if root['folder']
+        if root['folder'].kind_of? Array
+          root['child_folders'] = Array.new
+          root['folder'].each do |one|
+            root['child_folders'] << from_http_response(one)
+          end
+        else
+          root['child_folders'] = [from_http_response(root['folder'])]
+        end
+      else
+        root['child_folders'] = Array.new
+      end
+      super(root)
+    end
+  end
+
+  class UserParser < BaseParser # :nodoc:
+    def self.from_http_response(root)
+      add_int(root,'id','user_id')
+      add_boolean(root,'is_admin')
+      super(root)
+    end
+  end
+
+  # Parses the results from the test account request
+  class TestaccountParser < BaseParser # :nodoc:
+    def self.from_http_response(root)
+      root = root['testAccount']
+      add_int(root,'id','account_id')
+      add_int(root,'max_users')
+      add_boolean(root,'terms')
+      add_date(root,'expiration_date')
+      super(root)
+    end
+  end
+
+  # Factory for parsing an Account
+  class AccountParser < BaseParser # :nodoc:
+    def self.from_http_response(root)
+      add_int(root,'id','account_id')
+      add_int(root,'max_users')
+      add_boolean(root,'terms')
+      add_date(root,'expiration_date')
+      root['users'] = as_array(UsersParser.from_http_response(root))
+      super(root)
+    end
+  end
+
+  # Factory for parsing an Account
+  class DocumentParser < BaseParser # :nodoc:
+    def self.from_http_response(root)
+      add_int(root,'id','document_id')
+      add_int(root,'num_versions')
+      add_boolean(root,'is_private')
+      add_boolean(root,'is_public')
+      add_date(root,'create_date')
+      add_date(root,'mod_date')
+      add_date(root,'published_date')
+      root['owner'] = UserParser.from_http_response(root['owner'])
+      root['versions'] = as_array(VersionsParser.from_http_response(root))
+      super(root)
+    end
+  end
+
+  class VersionParser < BaseParser # :nodoc:
+    def self.from_http_response(root)
+      add_int(root,'id','version_id')
+      add_int(root,'num')
+      add_date(root,'create_date')
+      root['owner'] = UserParser.from_http_response(root['owner'])
+      super(root)
+    end
+  end
+
+  class OauthTokenCredentialsParser # :nodoc:
+    def self.from_http_response(root)
+      token = root['oauth_token_credentials']['oauth_token']
+      secret = root['oauth_token_credentials']['oauth_token_secret']
+      return AccessToken.new(token,secret)
+    end
+  end
+
 end