davetron5000-gliffy 0.1.1

data/lib/gliffy/response.rb

@@ -0,0 +1,127 @@
+require 'rexml/document'
+require 'array_has_response'
+require 'gliffy/rest'
+
+include REXML
+
+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
+  #
+  #
+  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])
+      else
+        response = Response.new
+      end
+
+      response.success = success
+      response.not_modified = not_modified
+
+      response
+    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
+
+    def success=(s); @success = s; end
+    def not_modified=(s); @not_modified = s; end
+
+    # Provides access to the rest implementation
+    attr_accessor :rest
+
+    protected
+
+    def initialize
+      @success = true
+      @not_modified = false
+    end
+
+    # Converts a dash-delimited string to a camel-cased classname
+    def self.to_classname(name)
+      classname = ""
+      name.split(/-/).each do |part|
+        classname += part.capitalize
+      end
+      classname
+    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)
+        end
+      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
+
+    def self.from_xml(element)
+      message = element.text
+      http_status = element.attributes['http-status'].to_i
+      Error.new(message,http_status)
+    end
+
+    def initialize(message,http_status)
+      super()
+      @message = message
+      @http_status = http_status
+    end
+
+    def to_s
+      "#{@http_status}: #{@message}"
+    end
+
+  end
+end

data/lib/gliffy/rest.rb

@@ -0,0 +1,110 @@
+require 'digest/md5'
+require 'cgi'
+require 'rubygems'
+require 'request_errors'
+require 'resource'
+require 'rest_client'
+
+require 'gliffy/config'
+require 'gliffy/url'
+
+require 'logger'
+
+module Gliffy
+
+  # Provides REST access to Gliffy, handling the signing of the requests
+  # but not the parsing of the results.  This class responds to the four primary HTTP methods:
+  #
+  # * get
+  # * put
+  # * post
+  # * delete
+  #
+  # Each method takes three parameters:
+  # [url] - the relative URL being requested
+  # [params] - a hash of parameters to include in the request (these are specific to the request, not things like apiKey or token)
+  # [headers] - any HTTP headers you want to set
+  #
+  # params and headers are optional.  These methods return whatever Gliffy sent back.  The context
+  # of the request should be used to determine the type, however it should be relatively safe to call
+  # Response#success? on whatever is returned to determine if everythign was OK
+  #
+  class Rest
+
+    # Provides access to the current token, 
+    # returning nil if none has been set
+    attr_accessor :current_token
+
+    # Provides access to the logger
+    # Do not set this to nil
+    attr_accessor :logger
+
+    attr_accessor :rest_client
+
+    # Create an accessor to the Gliffy REST api
+    #
+    def initialize
+      @current_token = nil
+      self.rest_client=RestClient
+      @logger = Logger.new(Config.config.log_device)
+      @logger.level = Config.config.log_level
+
+      @logger.debug("Creating #{self.class.to_s} with api_key of #{Config.config.api_key} against #{Config.config.gliffy_root}")
+    end
+
+    # Returns the complete URL that would be requested for
+    # the given URL and parameters
+    #
+    # [url] the URL, relative to the Gliffy API Root
+    # [params] a hash of parameters
+    #
+    def get_url(url,params=nil)
+      return create_url(url,params)
+    end
+
+    # Implements the http methods
+    def method_missing(symbol,*args)
+      if HTTP_METHODS[symbol]  && (args.length > 0)
+        url,params,headers = args
+        make_rest_request(symbol,url,params,headers)
+      else
+        if (HTTP_METHODS[symbol])
+          raise ArgumentError.new("Wrong number of arguments for method #{symbol.to_s}") 
+        else
+          super.method_missing(symbol,*args)
+        end
+      end
+    end
+
+    # Create the URL that would be needed to access the given resource with the given
+    # parameters
+    #
+    #   [+url+] url, relative to the gliffy root, to retrieve
+    #   [+params+] optional hash of parameters
+    #
+    def create_url(url,params=nil)
+      url = SignedURL.new(Config.config.api_key,Config.config.secret_key,Config.config.gliffy_root,url)
+      url.params=params if params
+      url['token'] = @current_token.token if @current_token
+
+      url.full_url
+    end
+
+    protected
+
+    def make_rest_request(method,url,params,headers)
+      headers = Hash.new if !headers
+      request_url = create_url(url,params)
+      @logger.debug("#{method.to_s.upcase} #{request_url}")
+      @rest_client.send(method,request_url,headers)
+    end
+
+    HTTP_METHODS = {
+      :get => true,
+      :put => true,
+      :delete => true,
+      :post => true,
+    };
+
+  end
+end

data/lib/gliffy/url.rb

@@ -0,0 +1,67 @@
+require 'gliffy/config'
+
+module Gliffy
+  # Handles signing and assembling the URL
+  class SignedURL
+
+    def initialize(api_key,secret_key,url_root,url)
+      raise ArgumentError.new("api_key is required") if !api_key
+      raise ArgumentError.new("secret_key is required") if !secret_key
+      raise ArgumentError.new("url_root is required") if !url_root
+      raise ArgumentError.new("url is required") if !url_root
+      @logger = Logger.new(Config.config.log_device)
+      @logger.level = Config.config.log_level
+      @params = Hash.new
+      @params['apiKey'] = api_key
+      @secret_key = secret_key
+      @url_root = url_root
+      @url = url
+    end
+
+    # Sets a request parameter
+    #
+    # [param] the name of the parameter, as a string
+    # [value] the value of the parameter, unencoded
+    #
+    def []=(param,value)
+      if (param == 'apiKey')
+        raise ArgumentError.new('You may not override the api_key in this way')
+      end
+      @params[param] = value
+    end
+
+    # Sets all request parameters to those in the hash.
+    def params=(params_hash)
+      api_key = @params['apiKey']
+      @params.replace(params_hash)
+      @params['apiKey'] = api_key
+    end
+
+    # Gets the full URL, signed and ready to be requested
+    def full_url
+      @logger.debug("Getting full_url of #{@url}")
+      to_sign = @url
+      url_params = Hash.new
+      @params.keys.sort.each do |key|
+        @logger.debug("Adding param #{key} (#{to_sign.class.to_s}, #{key.class.to_s}) : #{to_sign.to_s}")
+        to_sign += key
+        to_sign += @params[key].to_s
+        url_params[key.to_s] = @params[key].to_s
+      end
+      to_sign += @secret_key
+      @logger.debug("Signing '#{to_sign}'")
+      signature = Digest::MD5.hexdigest(to_sign)
+      signature.gsub!(/^0/,'') while (signature =~ /^0/)
+      @logger.debug("signature == '#{signature}'")
+      url_params['signature'] = signature
+
+      url = @url_root + @url + '?'
+      url_params.keys.sort.each do |key|
+        val = CGI::escape(url_params[key])
+        url += "#{key}=#{val}&"
+      end
+      url.gsub!(/\&$/,'')
+      return url
+    end
+  end
+end

data/lib/gliffy/user.rb

@@ -0,0 +1,72 @@
+require 'rexml/document'
+require 'array_has_response'
+require 'gliffy/rest'
+
+include REXML
+
+module Gliffy
+
+  # A user token
+  class UserToken < Response
+    attr_reader :expiration
+    attr_reader :token
+    def self.from_xml(element)
+      expiration = Time.at(element.attributes['expiration'].to_i / 1000)
+      token = element.text
+      UserToken.new(expiration,token)
+    end
+
+    def expired?
+      Time.now > expiration
+    end
+
+    def initialize(expiration,token)
+      super()
+      @expiration = expiration
+      @token = token
+    end
+
+  end
+
+  class Users < ArrayResponseParser; end
+
+  # A user of Gliffy and the main entry point to using the API (see #initiate_session)
+  class User < Response
+
+    # The user's username, which is their identifier within an account
+    attr_reader :username
+    # The user's email, which is unique to them in the entire Gliffy system.
+    # Note that this isn't guaranteed to be a real email, nor is
+    # it guaranteed to be the user's actual email.  This is 
+    # assigned by the system unless overridden by the API.
+    attr_reader :email
+    attr_reader :id
+
+    def self.from_xml(element)
+      id = element.attributes['id'].to_i
+      is_admin = false
+      is_admin = element.attributes['is-admin'] == 'true' if element.attributes['is-admin'] 
+      username = element.elements['username'] ? element.elements['username'].text : nil
+      email = element.elements['email'] ? element.elements['email'].text : nil
+
+      User.new(id,is_admin,username,email)
+    end
+
+    # Returns true if this user is an admin of the account in which they live
+    def is_admin?
+      @is_admin
+    end
+
+    protected
+
+    def initialize(id,is_admin,username,email)
+      super()
+      @id = id
+      @is_admin = is_admin
+      @username = username
+      @email = email
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: davetron5000-gliffy
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- David Copeland
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-22 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: technoweenie-rest-client
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.1
+    version: 
+description: 
+email: davidcopeland@naildrivin5.com
+executables: 
+- gliffy
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- ext/array_has_response.rb
+- lib/gliffy/account.rb
+- lib/gliffy/cli.rb
+- lib/gliffy/commands/commands.rb
+- lib/gliffy/config.rb
+- lib/gliffy/diagram.rb
+- lib/gliffy/folder.rb
+- lib/gliffy/gliffy.rb
+- lib/gliffy/response.rb
+- lib/gliffy/rest.rb
+- lib/gliffy/url.rb
+- lib/gliffy/user.rb
+- lib/gliffy.rb
+- bin/gliffy
+- README.rdoc
+has_rdoc: true
+homepage: http://davetron5000.github.com/gliffy
+post_install_message: 
+rdoc_options: 
+- --title
+- Gliffy Ruby Client
+- --main
+- README.rdoc
+- -ri
+require_paths: 
+- lib
+- ext
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: client to access the Gliffy API
+test_files: []
+