gliffy 0.0.6

data/README.md

@@ -0,0 +1,25 @@
+Gliffy API wrapper
+==================
+
+Basic usage
+-----------
+
+### Initialization
+
+api = Gliffy::API.new(ACCOUNT_ID, API_KEY, API_SECRET)
+api.impersonate('user@domain.com')
+api.account.root.documents
+
+### Working with documents
+
+doc = account.document(DOCUMENT_ID)
+doc.name
+doc.editor(RETURN_TO, RETURN_BUTTON_TEXT)
+doc.png.full
+
+### Navigating folders
+
+root = account.root
+root.folders[0].documents
+root.folders[1].name
+root.folders[1].path

data/lib/gliffy.rb

@@ -0,0 +1,33 @@
+require 'date'
+
+require 'gliffy/api'
+require 'gliffy/api/facade'
+require 'gliffy/api/response'
+require 'gliffy/account'
+require 'gliffy/document'
+require 'gliffy/document_png'
+require 'gliffy/folder'
+
+require 'gliffy/oauth/helper'
+
+module Gliffy
+  class << self
+    def default_application_name
+      "Gliffy Ruby Gem"
+    end
+
+    # some calls (e.g. OAuth token  generation) should be done through
+    # secure   HTTPS;  other   calls   (e.g.   actions  performed   by
+    # non-privileged accounts) should be done though plain HTTP
+    #
+    # We're using protocol-relative URL here.
+    def api_root
+      '//www.gliffy.com/api/1.0'
+    end
+
+    # We're using protocol-relative (//hosrname/path/ format) URL here.
+    def web_root
+      '//www.gliffy.com'
+    end
+  end
+end

data/lib/gliffy/account.rb

@@ -0,0 +1,59 @@
+module Gliffy
+  class Account
+    TYPE_BUSINESS = "Business"
+
+    attr_reader :api
+    attr_reader :id
+    attr_reader :name
+    attr_reader :max_users, :type, :terms_accepted
+    attr_reader :expiration_date
+
+    def self.load(api, response)
+      Gliffy::Account.new(
+        api,
+        :id => response.integer('//g:account/@id'),
+        :name => response.string('//g:account/g:name'),
+        :max_users => response.integer('//g:account/@max-users'),
+        :type => response.string('//g:account/@account-type'),
+        :terms_accepted => response.string('//g:account/@terms') == "true",
+        :expiration_date => response.timestamp('//g:account/g:expiration-date')
+      )
+    end
+
+    def root
+      @root ||= load_root
+    end
+
+    def document(document_id)
+      response = api.get("/accounts/#{id}/documents/#{document_id}/meta-data.xml",
+                         :action => 'get')
+
+      Gliffy::Document.load(
+        self,
+        response.node('//g:document')
+      )
+    end
+
+    private
+
+    def initialize(api, params)
+      @api = api
+
+      @id = params[:id]
+      @name = params[:name]
+      @max_users = params[:max_users]
+      @type = params[:type]
+      @terms_accepted = params[:terms_accepted]
+      @expiration_date = params[:expiration_date]
+    end
+
+    def load_root
+      response = api.get_folders(id)
+
+      Gliffy::Folder.load(
+        self,
+        response.node("/g:response/g:folders/g:folder")
+      )
+    end
+  end
+end

data/lib/gliffy/api.rb

@@ -0,0 +1,89 @@
+require 'uri'
+require 'oauth'
+require 'nokogiri'
+require 'cgi'
+
+module Gliffy
+  class API
+    attr_reader :consumer
+    attr_reader :account_id
+    attr_accessor :application_name
+
+    def initialize(account_id, key, secret)
+      @consumer = init_consumer(key, secret)
+      @account_id = account_id
+      @application_name = Gliffy.default_application_name
+    end
+
+    def plain
+      Gliffy::API::Facade.http(self)
+    end
+
+    def secure
+      Gliffy::API::Facade.https(self)
+    end
+
+    def get(url, params = {})
+      Gliffy::API::Response.new(Nokogiri.XML(raw(url, params)))
+    end
+
+    def raw(url, params = {})
+      r = token.get(url + '?' + query(params))
+      r.body
+    end
+
+    def post(url, params)
+      r = token.post(url, params)
+      Gliffy::API::Response.new(Nokogiri.XML(r.body))
+    end
+
+    def web(url, params)
+      consumer.create_signed_request(
+        :get, 
+        url + '?' + query(params), 
+        token
+      ).path
+    end
+
+    def account
+      @account ||= load_account
+    end
+
+    def impersonate(user)
+      escaped_id = URI.escape @account_id.to_s
+      escaped_user = URI.escape user
+
+      response = secure.post(
+        "/accounts/#{escaped_id}/users/#{escaped_user}/oauth_token.xml",
+        :action => 'create',
+        :description => application_name
+      )
+      
+      token.token = response.string('//g:oauth-token')
+      token.secret = response.string('//g:oauth-token-secret')
+    end
+
+    private
+
+    def query(params)
+      params.map {|k, v| "#{CGI.escape k.to_s}=#{CGI.escape v.to_s}" }.join('&')
+    end
+
+    def token
+      @token ||= OAuth::AccessToken.new @consumer
+    end
+
+    def load_account
+      response = plain.get("/accounts/#{account_id}.xml",
+                          { :action => 'get' })
+      Gliffy::Account.load(plain, response)
+    end
+
+    def init_consumer(key, secret)
+      OAuth::Consumer.new(key,
+                          secret,
+                          :site => Gliffy.web_root,
+                          :scheme => :query_string)
+    end
+  end
+end

data/lib/gliffy/api/facade.rb

@@ -0,0 +1,49 @@
+module Gliffy
+  class API
+    class Facade
+      def self.http(api)
+        Facade.new("http", api)
+      end
+
+      def self.https(api)
+        Facade.new("https", api)
+      end
+
+      def raw(partial_url, params = {})
+        @api.raw(api_root + partial_url, params)
+      end
+
+      def get(partial_url, params)
+        @api.get(api_root + partial_url, params)
+      end
+
+      def post(partial_url, params)
+        @api.post(api_root + partial_url, params)
+      end
+
+      def web(partial_url, params)
+        @api.web(web_root + partial_url, params)
+      end
+
+      def get_folders(account_id)
+        get("/accounts/#{account_id}/folders.xml",
+            :action => 'get')
+      end
+
+      private
+
+      def initialize(protocol, api)
+        @protocol = protocol
+        @api = api
+      end
+
+      def api_root
+        @protocol + ":" + Gliffy.api_root
+      end
+
+      def web_root
+        @protocol + ":" + Gliffy.web_root
+      end
+    end
+  end
+end

data/lib/gliffy/api/response.rb

@@ -0,0 +1,49 @@
+module Gliffy
+    class API::Response
+      def initialize(base)
+        @base = base
+      end
+
+      def content
+        @base.content
+      end
+
+      def nodes(path)
+        @base.xpath(path, namespaces).map { |n| Gliffy::API::Response.new(n) }
+      end
+
+      def node(path)
+        Gliffy::API::Response.new(@base.at_xpath(path, namespaces))
+      end
+
+      def string(path)
+        node(path).content
+      end
+
+      def integer(path)
+        string(path).to_i
+      end
+
+      def timestamp(path)
+        parse_timestamp(string(path))
+      end
+
+      def exists(path)
+        !@base.at_xpath(path, namespaces).nil?
+      end
+
+      private
+
+      # Gliffy XML namespace to be used in XPath expressions
+      def namespaces
+        { "g" => "http://www.gliffy.com" }
+      end
+
+      # As opposed to UNIX timestamp,  timestamps returned by Gliffy API
+      # are in  milliseconds, so  we should divide  them by  1000 before
+      # converting to real datetime objectsq
+      def parse_timestamp(value)
+        Time.at(value.to_i / 1000).to_datetime
+      end
+    end
+end

data/lib/gliffy/document.rb

@@ -0,0 +1,69 @@
+module Gliffy
+  class Document
+    attr_reader :owner
+    attr_reader :id
+    attr_reader :is_public
+    attr_reader :versions
+    attr_reader :name
+    attr_reader :modified, :created, :published
+
+    def self.load(owner, node)
+      @loaded ||= {}
+
+      id = node.integer('@id')
+      if not @loaded.has_key? id then
+        @loaded[id] = Gliffy::Document.new(
+          owner,
+          id,
+          :is_public => node.exists('@is-public'),
+          :versions => node.integer('@num-versions'),
+          :name => node.string('g:name'),
+          :modified => node.timestamp('g:mod-date'),
+          :created => node.timestamp('g:create-date'),
+          :published => node.timestamp('g:published-date')
+          )
+      end
+
+      @loaded[id]
+    end
+
+    def self.clear_cache
+      @loaded = {}
+    end
+
+    def editor(return_url, return_text)
+      api.web(
+        "/gliffy/",
+        :launchDiagramId => id,
+        :returnURL => return_url,
+        :returnButtonText => return_text
+      )
+    end
+
+    def png
+      Document::PNG.new(self)
+    end
+
+    def public?
+      is_public
+    end
+
+    def api
+      owner.api
+    end
+
+    private
+
+    def initialize(owner, id, params)
+      @owner = owner
+      @id = id
+
+      @is_public = params[:is_public]
+      @versions = params[:versions]
+      @name = params[:name]
+      @modified = params[:modified]
+      @created = params[:created]
+      @published = params[:published]
+    end
+  end
+end

data/lib/gliffy/document_png.rb

@@ -0,0 +1,56 @@
+module Gliffy
+  class Document::PNG
+    attr_reader :document
+
+    SIZE_THUMBNAIL = "T"
+    SIZE_SMALL = "S"
+    SIZE_MEDIUM = "M"
+    SIZE_FULL = "L"
+
+    def initialize(document)
+      @document = document
+    end
+
+    def content(size)
+      api.raw(
+        "/accounts/#{account_id}/documents/#{document_id}.png",
+        :action => 'get',
+        :size => size
+      )
+    end
+
+    def thumbnail
+      content(SIZE_THUMBNAIL)
+    end
+
+    def small
+      content(SIZE_SMALL)
+    end
+
+    def medium
+      content(SIZE_MEDIUM)
+    end
+
+    def full
+      content(SIZE_FULL)
+    end
+
+    private
+
+    def api
+      document.api
+    end
+
+    def account
+      document.owner
+    end
+
+    def document_id
+      document.id
+    end
+
+    def account_id
+      account.id
+    end
+  end
+end

data/lib/gliffy/folder.rb

@@ -0,0 +1,71 @@
+require 'uri'
+
+module Gliffy
+  class Folder
+    attr_reader :name, :path
+    attr_reader :owner, :parent
+    attr_reader :folders
+
+    def self.load(owner, node)
+      Gliffy::Folder.new(
+        owner,
+        node.string('g:name'),
+        node.string('g:path'),
+        node.nodes('g:folder').map {|n| Gliffy::Folder.load(owner, n)}
+      )
+    end
+
+    def initialize(owner, name, path, folders)
+      @owner = owner
+      @name = name
+      @path = path
+
+      @folders = folders
+      @folders.each do |f|
+        f.parent = self
+      end
+    end
+
+    def parent=(parent)
+      if path != parent.path + "/" + name then
+        raise "Invalid parent"
+      end
+
+      @parent = parent
+    end
+
+    def documents
+      @documents ||= load_documents
+    end
+
+    def root?
+      path == "ROOT"
+    end
+
+    private
+
+    def api
+      owner.api
+    end
+
+    def account_id
+      owner.id
+    end
+
+    def escaped_path
+      path.gsub(' ', '+')
+    end
+
+    def load_documents
+      # Path  is alphanumeric  +  spaces and  '/'.   Spaces should  be
+      # escaped; slashes should NOT be escaped.
+      url = "/accounts/#{account_id}/folders/#{escaped_path}/documents.xml"
+      response = api.get(url,
+                         :action => "get")
+
+      response
+        .nodes('//g:document')
+        .map { |n| Gliffy::Document.load(owner, n) }
+    end
+  end
+end