dewey 0.1.2

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+## 0.1.2 (June 28, 2010)
+
+Features:
+
+  - Removed dependency on xmlsimple. Processing was so minimal it was pointless.
+  
+---
+## 0.1.1 (June 28, 2010)
+
+Bugfixes:
+
+  - Mandate ~ 1.3 version of rspec
+  - Clear up YAML load issues

data/README.md

@@ -0,0 +1,32 @@
+Dewey allows you to simply upload, download and delete files from your Google
+Docs account. Let Google do all of the hard work of converting your documents!
+
+## Usage
+
+First, create a new Dewey::Document instance using your google docs account and
+password.
+
+    dewey = Dewey::Document.new(:account => 'example.account', :password => 'example')
+
+Next, choose a local document to upload or convert.
+
+    document = File.new('my_document.doc')
+    spreadsheet = File.new('my_spreadsheet.xls')
+
+Finally, handle the upload, download, and delete manually or use the convenient
+`convert` method.
+
+    dewey.convert(document, :html)
+    dewey.convert(spreadsheet, :csv)
+
+## Testing
+
+Until testing is converted to an offline solution you will have to provide some
+credentials for testing. All that is required is a valid Google Docs account, no
+fussing about with getting an application API.
+
+By default the spec will look for a file called dewey.yml inside of the spec 
+folder. The file should contain two lines:
+
+    email: <your gmail account>
+    password: <your gmail password>

data/TODO.md

@@ -0,0 +1,4 @@
+## Dewey TODO List
+  - Enable proper feed / service synchronization
+  - Correct spreadsheet support
+  - Add presentation support

data/lib/dewey.rb

@@ -0,0 +1,232 @@
+require 'uri'
+require 'net/https'
+require 'open-uri'
+require 'rexml/document'
+require 'tempfile'
+require 'dewey/https'
+require 'dewey/mime'
+require 'dewey/utils'
+
+module Dewey
+  GOOGLE_BASE_URL  = "https://www.google.com"
+  GOOGLE_DOCS_URL  = "https://docs.google.com"
+  GOOGLE_SPRD_URL  = "https://spreadsheets.google.com"
+  GOOGLE_LOGIN_URL = GOOGLE_BASE_URL + "/accounts/ClientLogin"
+  GOOGLE_FEED_URL  = GOOGLE_DOCS_URL + "/feeds/default/private/full"
+  
+  GOOGLE_DOCUMENT_URL    = GOOGLE_DOCS_URL + "/feeds/download/documents/Export"
+  GOOGLE_SPREADSHEET_URL = GOOGLE_SPRD_URL + "/feeds/download/spreadsheets/Export"
+  
+  GOOGLE_SERVICES = { :document => 'writely', :spreadsheet => 'wise' }
+  
+  DOCUMENT_EXPORT_FORMATS     = %w(txt odt pdf html rtf doc png zip)
+  PRESENTATION_EXPORT_FORMATS = %w(swf pdf png ppt)
+  SPREADSHEET_EXPORT_FORMATS  = %W(xls csv pdf ods tsv html)
+  
+  class DeweyException < Exception
+  end
+  
+  # Doc
+  # This base class handles authentication and requests
+  #
+  class Document
+    attr_accessor :account, :password, :service, :token, :cached
+    
+    # Determine wether or not a format is available for download.
+    #
+    # * format  - The file format to check, i.e. 'txt', 'doc', 'pdf'
+    # * service - The service that would be used. Must be document, presentation,
+    #   or spreadsheet.
+    def self.valid_upload_format?(format, service = :document)
+      case service
+      when :document     then Dewey::DOCUMENT_MIMETYPES.has_key?(format.to_sym)
+      when :presentation then Dewey::PRESENTATION_MIMETYPES.has_key?(format.to_sym)
+      when :spreadsheet  then Dewey::SPREADSHEET_MIMETYPES.has_key?(format.to_sym)
+      else
+        raise DeweyException, "Unknown service: #{service}"
+      end
+    end
+    
+    # Determine whether or not a format is available for export.
+    #
+    # * format  - The file format to check, i.e. 'txt', 'doc', 'pdf'
+    # * service - The service that would be used. Must be document, presentation,
+    #   or spreadsheet.
+    def self.valid_export_format?(format, service = :document)
+      case service
+      when :document     then DOCUMENT_EXPORT_FORMATS.include?(format)
+      when :presentation then PRESENTATION_EXPORT_FORMATS.include?(format)
+      when :spreadsheet  then SPREADSHEET_EXPORT_FORMATS.include?(format)
+      else
+        raise DeweyException, "Unknown service: #{service}"
+      end
+    end
+    
+    # Create a new Doc object
+    # Options specified in +opts+ consist of:
+    #
+    # * :account - The Google Doc's account that will be used for authentication.
+    #   This will most typically be a gmail account, i.e. +example@gmail.com+
+    # * :password - The password for the Google Doc's account.
+    # * :service - The default service to connect to, either :document or :spreadsheet
+    def initialize(options = {})
+      @account  = options[:account]
+      @password = options[:password]
+      @service  = options[:service] || :document
+      @cached   = {}
+    end
+    
+    # Returns true if this instance has been authorized
+    def authorized?
+      !! @token
+    end
+    
+    # Gets an authorization token for this instance. Raises an error if no
+    # credentials have been provided, +false+ if authorization fails, and +true+ if
+    # authorization is successful.
+    def authorize!
+      if @account.nil? || @password.nil?
+        raise DeweyException, "Account or password missing."
+      end
+      
+      url = URI.parse(GOOGLE_LOGIN_URL)
+      params = { 'accountType' => 'HOSTED_OR_GOOGLE', 'Email' => @account,
+                 'Passwd' => @password, 'service'=> GOOGLE_SERVICES[@service] }
+      
+      response = Net::HTTPS.post_form(url, params)
+      
+      case response
+      when Net::HTTPSuccess
+        @token = response.body.split(/=/).last
+        true
+      when Net::HTTPForbidden
+        false
+      else
+        raise DeweyException, "Unexpected response: #{response}"
+      end
+    end
+        
+    def upload(file, title = nil)
+      extension = File.extname(file.path).sub('.', '')
+      basename  = File.basename(file.path, ".#{extension}")
+      mimetype  = Dewey::Mime.mime_type(file)
+      service   = Dewey::Mime.guess_service(mimetype)
+      
+      title ||= basename
+      
+      raise DeweyException, "Invalid file type: #{extension}" unless Dewey::Document.valid_upload_format?(extension, service)
+      
+      headers = base_headers
+      headers['Content-Length'] = File.size?(file).to_s
+      headers['Content-Type']   = mimetype
+      headers['Slug']           = Dewey::Utils.escape(title)
+      
+      # Rewind the file in the case of multiple uploads, or conversions
+      file.rewind
+      
+      response = post_request(GOOGLE_FEED_URL, file.read.to_s, headers)
+      
+      case response
+      when Net::HTTPCreated
+        rid = @cached[basename] = extract_rid(response.body)
+      else
+        nil
+      end
+    end
+    
+    # Download, or export more accurately, a file to a specified format
+    # * id     - A resource id or exact file name matching a document in the account
+    # * format - The output format, see *_EXPORT_FORMATS for possiblibilites
+    def download(id, format = nil)
+      spreadsheet = !! id.match(/spreadsheet/)
+      
+      url  = (spreadsheet ? GOOGLE_SPREADSHEET_URL : GOOGLE_DOCUMENT_URL)
+      url << (spreadsheet ? "?key=#{id}" : "?docID=#{id}")
+      url << "&exportFormat=#{format.to_s}" unless format.nil?
+      
+      headers = base_headers
+      
+      file = Tempfile.new([id, format].join('.'))
+      file.binmode
+      
+      open(url, headers) { |data| file.write data.read }
+      
+      file
+    end
+    
+    # Deletes a document referenced either by resource id or by name.
+    def delete(id)
+      headers = base_headers
+      headers['If-Match'] = '*' # We don't care if others have modified
+      
+      url = GOOGLE_FEED_URL + "/#{Dewey::Utils.escape(id)}?delete=true"
+      response = delete_request(url, headers)
+      
+      case response
+      when Net::HTTPOK
+        true
+      else
+        false
+      end
+    end
+    
+    # Convenience method for +upload+, +download+, +delete+. Returns a Tempfile
+    # with in the provided type.
+    # * file    - The file that will be converted
+    # * options - Takes :title and :format. See +upload+ for title, and +download+
+    #             for format.
+    def convert(file, options = {})
+      rid = upload(file, options[:title])
+      con = download(rid, options[:format])
+      
+      delete(rid)
+      
+      con
+    end
+    
+    private
+    
+    def post_request(url, data, headers) #:nodoc:
+      http_request(:post, url, headers, data)
+    end
+    
+    def delete_request(url, headers) #:nodoc:
+      http_request(:delete, url, headers)
+    end
+    
+    def http_request(method, url, headers, data = nil) #:nodoc:      
+      url = URI.parse(url) if url.kind_of? String
+      
+      connection = Net::HTTP.new(url.host, url.port)
+      connection.use_ssl = (url.scheme == 'https')
+      
+      case method
+      when :post
+        connection.post(url.path, data, headers)
+      when :delete
+        connection.delete(url.path, headers)
+      else
+        raise DeweyException, "Invalid request type. Valid options are :post and :delete"
+      end
+    end
+    
+    def base_headers #:nodoc:
+      base = {}
+      base['GData-Version'] = '3.0'
+      base['Content-Type']  = 'application/x-www-form-urlencoded'
+      base['Authorization'] = "GoogleLogin auth=#{@token}" if authorized?
+      
+      base
+    end
+    
+    def extract_rid(source) #:nodoc:
+      xml = REXML::Document.new(source)
+      
+      begin
+        "#{$1}:#{$2}" if xml.elements['//id'].text =~ /.+(document|spreadsheet|presentation)%3A([0-9a-zA-Z]+)/
+      rescue 
+        raise DeweyException, "id could not be extracted from: #{body}"
+      end
+    end
+  end
+end

data/lib/dewey/https.rb

@@ -0,0 +1,11 @@
+require 'net/http'
+
+# Shortcut method for using +http.use_ssl+.
+module Net
+  class HTTPS < Net::HTTP
+    def initialize(address, port = 443)
+      super(address, port)
+      self.use_ssl = true
+    end
+  end
+end

data/lib/dewey/mime.rb

@@ -0,0 +1,84 @@
+# (c) Copyright 2010 Parker Selbert <parker@sorentwo.com>
+#
+# Dewey is freely distributable under the terms of an MIT-style license.
+# See LICENSE or http://www.opensource.org/licenses/mit-license.php
+
+module Dewey
+  
+  DOCUMENT_MIMETYPES = {
+    :doc  => 'application/msword',
+    :docx => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    :htm  => 'text/html',
+    :html => 'text/html',
+    :odt  => 'application/vnd.oasis.opendocument.text',
+    :pdf  => 'application/pdf',
+    :rtf  => 'application/rtf',
+    :sxw  => 'application/vnd.sun.xml.writer',
+    :txt  => 'text/plain'
+  }
+  
+  PRESENTATION_MIMETYPES = {
+    :pps => 'application/vnd.ms-powerpoint',
+    :ppt => 'application/vnd.ms-powerpoint'
+  }
+  
+  SPREADSHEET_MIMETYPES = {
+    :csv  => 'text/csv',
+    :ods  => 'application/x-vnd.oasis.opendocument.spreadsheet',
+    :tab  => 'text/tab-separated-values',
+    :tsv  => 'text/tab-separated-values',
+    :xls  => 'application/vnd.ms-excel',
+    :xlsx => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+  }
+  
+  class Mime
+    # Attempts to provide a mime_type that Google Docs finds acceptable. Certain
+    # types, when gathered from +file+ require extra coercion and will be handled
+    # automatically.
+    def self.mime_type(file)
+      type = (file.path.match(/\.(\w+)/)[1]).downcase
+      case type
+      when /csv/  then SPREADSHEET_MIMETYPES[:csv]
+      when /doc$/ then DOCUMENT_MIMETYPES[:doc]
+      when /docx/ then DOCUMENT_MIMETYPES[:docx]
+      when /htm/  then DOCUMENT_MIMETYPES[:html]
+      when /ods/  then SPREADSHEET_MIMETYPES[:ods]
+      when /odt/  then DOCUMENT_MIMETYPES[:odt]
+      when /pdf/  then DOCUMENT_MIMETYPES[:pdf]
+      when /pps/  then PRESENTATION_MIMETYPES[:pps]
+      when /ppt/  then PRESENTATION_MIMETYPES[:ppt]
+      when /rtf/  then DOCUMENT_MIMETYPES[:rtf]
+      when /sxw/  then DOCUMENT_MIMETYPES[:sxw]
+      when /tab/  then SPREADSHEET_MIMETYPES[:tab]
+      when /tsv/  then SPREADSHEET_MIMETYPES[:tsv]
+      when /txt/  then DOCUMENT_MIMETYPES[:txt]
+      when /xls$/ then SPREADSHEET_MIMETYPES[:xls]
+      when /xlsx/ then SPREADSHEET_MIMETYPES[:xlsx]
+      else
+        Mime.coerce((`file --mime-type #{file.path}`).split(':').last.strip) rescue "application/#{type}"
+      end
+    end
+    
+    # Attempt to take mime types that are known to be guessed incorrectly and
+    # cast them to one that Google Docs will accept.
+    def self.coerce(mime_type)
+      case mime_type
+      when /vnd.ms-office/ then 'application/msword'
+      when /x-docx/        then 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+      else mime_type
+      end
+    end
+    
+    def self.guess_service(mime_type)
+      services = { :document     => DOCUMENT_MIMETYPES,
+                   :presentation => PRESENTATION_MIMETYPES,
+                   :spreadsheet  => SPREADSHEET_MIMETYPES }
+      
+      services.each_key do |service|
+        return service if services[service].has_value?(mime_type)
+      end
+      
+      nil
+    end
+  end
+end

data/lib/dewey/utils.rb

@@ -0,0 +1,19 @@
+module Dewey
+  module Utils #:nodoc:
+    # Performs URI escaping. (Stolen from Camping via Rake).
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+        '%'+$1.unpack('H2' * bytesize($1)).join('%').upcase
+      }.tr(' ', '+')
+    end
+    
+    module_function :escape
+    
+    # Return the bytesize of String; uses String#length under Ruby 1.8 and
+     def bytesize(string)
+       string.bytesize
+     end
+     
+     module_function :bytesize
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: dewey
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Parker Selbert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-29 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Dewey is a no-frills tool for utilizing Google Docs ability to convert documents between formats
+email: 
+- parker@sorentwo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dewey/https.rb
+- lib/dewey/mime.rb
+- lib/dewey/utils.rb
+- lib/dewey.rb
+- README.md
+- CHANGELOG.md
+- TODO.md
+has_rdoc: true
+homepage: http://github.com/sorentwo/dewey
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: dewey
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Google Docs fueled document conversion
+test_files: []
+