RubyGems - vuzitruby - Versions diffs - 1.1.0 → 1.2.0 - Mend

vuzitruby 1.1.0 → 1.2.0

Files changed (8) hide show

data/README +6 -6
data/bin/vuzitcl +180 -87
data/lib/vuzitruby/base.rb +117 -0
data/lib/vuzitruby/{exception.rb → client_exception.rb} +2 -12
data/lib/vuzitruby/document.rb +66 -177
data/lib/vuzitruby/service.rb +22 -23
data/lib/vuzitruby.rb +2 -1
metadata +4 -3

data/README CHANGED Viewed

@@ -32,8 +32,8 @@ The client library is a RubyGem called *vuzitruby*. To install, type:
 * Download the code - http://github.com/vuzit/vuzitruby/downloads
 * Sign up for a free Vuzit account - https://ssl.vuzit.com/signup
-* Code Examples - http://wiki.github.com/vuzit/vuzitruby/code-examples
-* Vuzit API Reference - http://doc.vuzit.com/vuzitruby
+* Code Examples - http://wiki.github.com/vuzit/vuzitruby/code_examples
+* Vuzit API Reference - http://wiki.github.com/vuzit/vuzitruby/api_reference
 * VuzitCL Command Line - http://wiki.github.com/vuzit/vuzitruby/vuzitcl
 == EXAMPLES
@@ -69,16 +69,16 @@ Upload and View with the JavaScript API Example for a Rails RHTML file:
   doc = Vuzit::Document.upload("c:/path/to/document.pdf")
   timestamp = Time.now
-  sig = Vuzit::Service.get_signature("show", doc.id, timestamp)
+  sig = Vuzit::Service.signature("show", doc.id, timestamp)
   %>
   <html>
     <head>
-      <link href="http://vuzit.com/stylesheets/Vuzit-2.6.css" rel="Stylesheet" type="text/css" />
-      <script src="http://vuzit.com/javascripts/Vuzit-2.6.js" type="text/javascript"></script>
+      <link href="http://vuzit.com/stylesheets/Vuzit-2.9.css" rel="Stylesheet" type="text/css" />
+      <script src="http://vuzit.com/javascripts/Vuzit-2.9.js" type="text/javascript"></script>
       <script type="text/javascript">
         // Called when the page is loaded.
         function initialize()  {
-          vuzit.Base.PublicKeySet("<%= Vuzit::Service.public_key %>");
+          vuzit.Base.apiKeySet("<%= Vuzit::Service.public_key %>");
           var options = {signature: '<%= CGI.escape(sig) %>',
                          timestamp: '<%= timestamp %>', ssl: true}
           var viewer = vuzit.Viewer.fromId("<%= doc.id %>", options);

data/bin/vuzitcl CHANGED Viewed

@@ -7,99 +7,95 @@ require 'pp'
 require File.dirname(__FILE__) + '/../lib/vuzitruby'
-class ParseOptions
-  # Parse the command line options.
-  def self.parse(args)
-    options = OpenStruct.new
-    options.key = nil
-    options.id = nil
-    options.upload = nil
-    options.public = false
-    options.delete = nil
-    options.load = nil
-    options.service_url = nil
-    options.verbose = false
-    opts = OptionParser.new do |opts|
-      opts.banner = "VuzitCL - Vuzit Command Line\n"
-      opts.banner += "Usage: vuzitcl -k [PUBLIC_KEY],[PRIVATE_KEY] [OPTIONS]"
-      opts.separator ""
-      opts.separator "Options:"
-      opts.on("-k", "--keys [PUB_KEY],[PRIV_KEY]",
-              "Developer API keys - REQUIRED") do |value|
-        options.key = value
-      end
-      opts.on("-u", "--upload [PATH]", "File to upload") do |value|
-        options.upload = value
-      end
-      opts.on("-p", "--public", "Make uploaded file public") do |value|
-        options.public = true
-      end
-      opts.on("-l", "--load [ID]", "Loads the document data") do |value|
-        options.load = value
-      end
-      opts.on("-d", "--delete [ID]", "Deletes a document") do |value|
-        options.delete = value
-      end
-      opts.on("-s", "--service-url [URL]", "Sets the service URL") do |value|
-        options.service_url = value
-      end
-      opts.on("-v", "--verbose", "Prints more messages") do
-        options.verbose = true
-      end
-      opts.on_tail("-h", "--help", "Show this message") do
-        puts opts
-        exit
-      end
+# GENERAL METHODS
+# Prints an error message
+def error(message)
+  puts ''
+  puts message
+end
+# Loads the global parameters
+def global_parameters_load(args)
+  options = OpenStruct.new
+  options.key = nil
+  options.id = nil
+  opts = OptionParser.new do |opts|
+    opts.on("-k", "--keys=PUB_KEY,PRIV_KEY",
+            "Developer API keys - REQUIRED") do |value|
+      options.key = value
     end
-    if args.length < 1
-      puts opts
+    opts.on("-s", "--service-url=URL", "Sets the service URL") do |value|
+      options.service_url = value
     end
+  end
+  begin
     opts.parse!(args)
-    return options
-  end  # parse()
+  rescue OptionParser::InvalidOption => e
+    e.recover(args)
+  end
-end
+  if options.key == nil
+    error("Must provide the --keys parameters")
+    return false
+  end
-def error(message)
-  puts ''
-  puts message
-end
+  keys = options.key.split(',')
-# Parse the options and run the program.
-options = ParseOptions.parse(ARGV)
+  Vuzit::Service.public_key = keys[0]
+  Vuzit::Service.private_key = keys[1]
+  Vuzit::Service.user_agent = "VuzitCL Ruby 1.1.0"
-if options.key == nil
-  error "ERROR: Public and private keys are required"
-  exit
+  if options.service_url != nil
+    Vuzit::Service.service_url = options.service_url
+  end
+  return true
 end
-Vuzit::Service.public_key = options.key.split(',')[0]
-Vuzit::Service.private_key = options.key.split(',')[1]
+# COMMAND FUNCTIONS
+# Performs the delete command.
+def delete_command(args)
+  id = args.pop
+  return if !global_parameters_load(args)
-if options.service_url != nil
-  Vuzit::Service.service_url = options.service_url
+  begin
+    doc = Vuzit::Document.destroy(id)
+    puts "DELETED: #{id}"
+  rescue Vuzit::ClientException => ex
+    error "Error occurred: #{ex.code}, #{ex.message}"
+  end
 end
-if options.verbose == true
-  Vuzit::Service.debug = true
+# Handles the help command
+def help_command(args)
+  command = args.pop
+  case command
+  when "load"
+    print_usage_load
+  when "delete"
+    print_usage_delete
+  when "upload"
+    print_usage_upload
+  else
+    error("Unknown option: [#{command}]")
+  end
 end
-if options.load != nil
+# Performs the load command.
+def load_command(args)
+  id = args.pop
+  return if !global_parameters_load(args)
   begin
-    doc = Vuzit::Document.find(options.load)
+    doc = Vuzit::Document.find(id)
     puts "LOADED: #{doc.id}"
     puts "title: #{doc.title}"
     puts "subject: #{doc.subject}"
@@ -107,24 +103,121 @@ if options.load != nil
     puts "width: #{doc.page_width}"
     puts "height: #{doc.page_height}"
     puts "size: #{doc.file_size}"
-  rescue Vuzit::Exception => ex
+    puts "status: #{doc.status}"
+  rescue Vuzit::ClientException => ex
     puts "Error occurred: #{ex.code}, #{ex.message}"
   end
-elsif options.delete != nil
+end
+# Performs the load command.
+def upload_command(args)
+  path = args.pop
+  return if !global_parameters_load(args)
+  list = Hash.new
+  opts = OptionParser.new do |opts|
+    opts.on("-s", "--secure", "") do
+      list[:secure] = true
+    end
+    opts.on("-p", "--download-pdf", "") do
+      list[:download_pdf] = true
+    end
+    opts.on("-d", "--download-document", "") do
+      list[:download_document] = true
+    end
+  end
   begin
-    doc = Vuzit::Document.destroy(options.delete)
-    puts "DELETED: #{options.delete}"
-  rescue Vuzit::Exception => ex
-    error "Error occurred: #{ex.code}, #{ex.message}"
+    opts.parse!(args)
+  rescue OptionParser::InvalidOption => e
+    e.recover(args)
   end
-elsif options.upload != nil
   begin
-    doc = Vuzit::Document.upload(options.upload, :secure => !options.public)
+    doc = Vuzit::Document.upload(path, list)
     puts "UPLOADED: #{doc.id}"
-  rescue Vuzit::Exception => ex
+  rescue Vuzit::ClientException => ex
     error "Error occurred: #{ex.code}, #{ex.message}"
   end
-else
-  error "Please select an option"
+end
+# PRINT USAGE METHODS
+# Prints the delete usage.
+def print_usage_delete
+  puts "delete: Delete a document"
+  puts "usage: delete [OPTIONS] WEB_ID"
+  puts ""
+  puts "Valid options:"
+  puts "  none"
+  puts ""
+  print_usage_global
+end
+# Prints the general usage
+def print_usage_general
+  puts "VuzitCL - Vuzit Command Line"
+  puts "Usage: vuzitcl COMMAND -k PUBLIC_KEY,PRIVATE_KEY [OPTIONS]"
+  puts ""
+  puts "Type 'vuzitcl help <command>' for help on a specific command."
+  puts ""
+  puts "Available commands:"
+  puts ""
+  puts "  upload"
+  puts "  delete"
+  puts "  load"
+  puts "  help"
+end
+# Prints the global options
+def print_usage_global
+  puts "Global Options:"
+  puts "  -k, --keys=PUB_KEY,PRIV_KEY    Developer API keys - REQUIRED"
+  puts "  -u, --service-url=URL          Sets the service URL (e.g. http://domain.com)"
+end
+# Prints the load options
+def print_usage_load
+  puts "load: Loads a document"
+  puts "usage: load [OPTIONS] WEB_ID"
+  puts ""
+  puts "Valid options:"
+  puts "  none"
+  puts ""
+  print_usage_global
+end
+# Prints the upload options
+def print_usage_upload
+  puts "upload: Upload a file to Vuzit."
+  puts "usage: upload [OPTIONS] PATH"
+  puts ""
+  puts "Valid options:"
+  puts "  -s, --secure                   Make the document secure (not public)"
+  puts "  -p, --download-pdf             Make the PDF downloadable"
+  puts "  -d, --download-document        Make the original document downloadable"
+  puts ""
+  print_usage_global
+end
+# MAIN CODE EXECUTION
+command = ARGV.shift
+case command
+  when "load"
+    load_command(ARGV)
+  when "delete"
+    delete_command(ARGV)
+  when "upload"
+    upload_command(ARGV)
+  when "help"
+    help_command(ARGV)
+  else
+    error("Unknown command: [#{command}]")
+    print_usage_general
 end

data/lib/vuzitruby/base.rb ADDED Viewed

@@ -0,0 +1,117 @@
+require 'cgi'
+module Vuzit
+  # Base web client class for the Vuzit library.
+  class Base
+    protected
+    # Returns true if a value is a Boolean.
+    def self.bool?(value)
+      return value.is_a?(TrueClass) || value.is_a?(FalseClass)
+    end
+    # Returns true if the value is empty.
+    def self.empty?(value)
+      return (value == nil) || value.to_s.length < 1
+    end
+    # Returns an HTTP connection
+    def self.http_connection()
+      uri = URI.parse(Vuzit::Service.service_url)
+      result = Net::HTTP.new(uri.host, uri.port)
+      if Vuzit::Service.service_url[0, 8] == "https://"
+        result.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        result.use_ssl = true
+      end
+      return result
+    end
+    # Returns a clean version of the parameters hash table.
+    def self.parameters_clean(params)
+      result = Hash.new
+      params.each_pair do |key, value|
+        if bool?(value)
+          value = value ? "1" : "0"
+        end
+        if !empty?(value)
+          result[key] = value
+        end
+      end
+      return result
+    end
+    # Converts a set of parameters to a URL.
+    def self.parameters_to_url(resource, params, id = nil, extension = 'xml')
+      params = parameters_clean(params)
+      result = ''
+      result << Vuzit::Service.service_url.to_s << "/" << resource
+      result << ("/" << id) if !id.nil?
+      result << "." << extension << "?"
+      params.each_pair do |key, value|
+        result << (key.to_s << "=" << CGI.escape(value.to_s) << "&")
+      end
+      return result
+    end
+    # Returns the default HTTP post parameters hash.
+    def self.post_parameters(method, params, id = '')
+      params = Hash.new if params.nil?
+      params[:method] = method
+      params[:key] = Vuzit::Service.public_key
+      timestamp = Time.now
+      params[:timestamp] = timestamp.to_i # time since epoch
+      pages = ''
+      if params.has_key?(:included_pages)
+        pages = params[:included_pages]
+      end
+      label = ''
+      signature = Vuzit::Service::signature(method, id, timestamp, pages, label)
+      params[:signature] = signature
+      return params
+    end
+    # Makes a HTTP POST.
+    def self.send_request(method, fields = {})
+      raise ArgumentError, "Method should be given" if method.nil? || method.empty?
+      http = http_connection
+      # API methods can be slow.
+      http.read_timeout = 15 * 60
+      request = Net::HTTP::Post.new('/documents', {'User-Agent' => Vuzit::Service.user_agent})
+      request.multipart_params = parameters_clean(fields)
+      tries = 3
+      begin
+        tries -= 1
+        res = http.request(request)
+      rescue Exception
+        $stderr.puts "Request encountered error, will retry #{tries} more."
+        if tries > 0
+          # Retrying several times with sleeps is recommended.
+          # This will prevent temporary downtimes
+          sleep(20)
+          retry
+        end
+        raise $!
+      end
+      return res
+    end
+  end
+end

data/lib/vuzitruby/{exception.rb → client_exception.rb} RENAMED Viewed

@@ -1,7 +1,7 @@
 module Vuzit
   # Vuzit library exception handler class.
-  class Exception < StandardError
+  class ClientException < StandardError
     # The web service error message
     attr_reader :message
@@ -9,24 +9,14 @@ module Vuzit
     attr_reader :code
     # Constructor for errors.
-    #
-    # Example:
-    #
-    #  begin
-    #    doc = Vuzit::Document.find("DOCUMENT_ID")
-    #  rescue Vuzit::Exception => ex
-    #    puts "Error code: #{ex.code}, message: #{ex.message}"
-    #  end
     def initialize(message, code = 0)
       @message = message
       @code = code
     end
     # Returns the string representation of the error in this format:
-    #
-    #  Vuzit::Exception: [CODE]: MESSAGE
     def to_s
-      return "Vuzit::Exception: [#{@code}]: #{@message}";
+      return "Vuzit::ClientException: [#{@code}]: #{@message}";
     end
   end
 end

data/lib/vuzitruby/document.rb CHANGED Viewed

@@ -1,75 +1,34 @@
 require 'rexml/document'
-require 'uri'
-require 'cgi'
-class Hash #:nodoc:all
-   # Taken from Rails, with appreciation to DHH
-   def stringify_keys
-     inject({}) do |options, (key, value)|
-       options[key.to_s] = value
-       options
-     end
-   end unless method_defined?(:stringify_keys)
-end
 module Vuzit
   # Class for uploading, loading, and deleting documents using the Vuzit Web
   # Service API: http://vuzit.com/developer/documents_api
-  #
-  # To use this class you need to {sign up}[http://vuzit.com/signup] for
-  # Vuzit first.
-  class Document
-    # The document ID
-    attr_accessor :id
-    # The document title
-    attr_accessor :title
-    # The document subject
-    attr_accessor :subject
-    # Number of pages of the document
-    attr_accessor :page_count
-    # Page width of the document in pixels
-    attr_accessor :page_width
-    # Page height of the document in pixels
-    attr_accessor :page_height
-    # File size of the original document bytes
-    attr_accessor :file_size
-    TRIES = 3 #:nodoc:
+  class Document < Base
+    attr_reader :id # The document ID
+    attr_reader :title # The document title
+    attr_reader :subject # The document subject
+    attr_reader :page_count # Number of pages of the document
+    attr_reader :page_width # Page width of the document in pixels
+    attr_reader :page_height # Page height of the document in pixels
+    attr_reader :file_size # File size of the original document bytes
+    attr_reader :status # Status of the document
     # Constructor.
     def initialize #:nodoc:
       # Set the defaults
       @id = @title = @subject = nil
-      @page_count = @page_width = @page_height = @file_size = -1
+      @page_count = @page_width = @page_height = @file_size = @status = -1
     end
     # Deletes a document by the ID.  Returns true if it succeeded.  It throws
-    # a Vuzit::Exception on failure.  It returns _true_ on success.
-    #
-    # Example:
-    #
-    #  Vuzit::Service.public_key = 'YOUR_PUBLIC_API_KEY'
-    #  Vuzit::Service.private_key = 'YOUR_PRIVATE_API_KEY'
-    #
-    #  result = Vuzit::Document.destroy("DOCUMENT_ID")
+    # a Vuzit::ClientException on failure.  It returns _true_ on success.
     def self.destroy(id)
-      timestamp = Time.now
-      sig = CGI.escape(Vuzit::Service::get_signature('destroy', id, timestamp))
+      params = post_parameters("destroy", nil, id)
+      url = parameters_to_url("documents", params, id)
+      http = http_connection
-      # Create the connection
-      uri = URI.parse(Vuzit::Service.service_url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      query = "/documents/#{id}.xml?key=#{Vuzit::Service.public_key}" +
-              "&signature=#{sig}&timestamp=#{timestamp.to_i}"
-      request = Net::HTTP::Delete.new(query)
+      request = Net::HTTP::Delete.new(url, {'User-Agent' => Vuzit::Service.user_agent})
       response = http.start { http.request(request) }
       if response.code.to_i != 200
@@ -77,46 +36,38 @@ module Vuzit
         begin
           doc = REXML::Document.new(response.body)
         rescue Exception => ex
-          raise Vuzit::Exception.new("XML error: #{ex.message}")
+          raise Vuzit::ClientException.new("XML error: #{ex.message}")
         end
         if doc.root != nil
           code = doc.root.elements['code']
           if code != nil
-            raise Vuzit::Exception.new(doc.root.elements['msg'].text, code.text.to_i);
+            raise Vuzit::ClientException.new(doc.root.elements['msg'].text, code.text.to_i);
           end
         end
         # At this point we don't know what the error is
-        raise Vuzit::Exception.new("Unknown error occurred #{response.message}", response.code)
+        raise Vuzit::ClientException.new("Unknown error occurred #{response.message}", response.code)
       end
-      debug(response.code + " " + response.message + "\n")
       return true
     end
-    # Finds a document by the ID.  It throws a Vuzit::Exception on failure.
-    #
-    # Example:
-    #
-    #  Vuzit::Service.public_key = 'YOUR_PUBLIC_API_KEY'
-    #  Vuzit::Service.private_key = 'YOUR_PRIVATE_API_KEY'
-    #
-    #  doc = Vuzit::Document.find("DOCUMENT_ID")
-    #  puts doc.id
-    #  puts doc.title
-    def self.find(id)
-      timestamp = Time.now
-      sig = CGI.escape(Vuzit::Service::get_signature('show', id, timestamp))
-      # Create the connection
-      uri = URI.parse(Vuzit::Service.service_url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      query = "/documents/#{id}.xml?key=#{Vuzit::Service.public_key}" +
-              "&signature=#{sig}&timestamp=#{timestamp.to_i}"
-      request = Net::HTTP::Get.new(query)
+    # Returns a download URL.
+    def self.download_url(id, file_extension)
+      params = post_parameters("show", nil, id)
+      return parameters_to_url("documents", params, id, file_extension)
+    end
+    # Finds a document by the ID.  It throws a Vuzit::ClientException on failure.
+    def self.find(id, options = {})
+      raise ArgumentError, "Options must be a hash" unless options.kind_of? Hash
+      params = post_parameters("show", options, id)
+      url = parameters_to_url("documents", params, id)
+      http = http_connection
+      request = Net::HTTP::Get.new(url, {'User-Agent' => Vuzit::Service.user_agent})
       response = http.start { http.request(request) }
       # TODO: Check if response.code.to_i != 200
@@ -124,153 +75,91 @@ module Vuzit
       begin
         doc = REXML::Document.new(response.body)
       rescue Exception => ex
-        raise Vuzit::Exception.new("XML error: #{ex.message}")
+        raise Vuzit::ClientException.new("XML error: #{ex.message}")
       end
       if doc.root == nil
-        raise Vuzit::Exception.new("No response from server");
+        raise Vuzit::ClientException.new("No response from server");
       end
-      debug(response.code + " " + response.message + "\n" + response.body)
       code = doc.root.elements['code']
       if code != nil
-        raise Vuzit::Exception.new(doc.root.elements['msg'].text, code.text.to_i);
+        raise Vuzit::ClientException.new(doc.root.elements['msg'].text, code.text.to_i);
       end
       id = doc.root.elements['web_id']
       if id == nil
-        raise Vuzit::Exception.new("Unknown error occurred");
+        raise Vuzit::ClientException.new("Unknown error occurred");
       end
       result = Vuzit::Document.new
-      result.id = id.text
-      result.title = doc.root.elements['title'].text
-      result.subject = doc.root.elements['subject'].text
-      result.page_count = doc.root.elements['page_count'].text.to_i
-      result.page_width = doc.root.elements['width'].text.to_i
-      result.page_height = doc.root.elements['height'].text.to_i
-      result.file_size = doc.root.elements['file_size'].text.to_i
+      result.send(:set_id, id.text)
+      result.send(:set_title, doc.root.elements['title'].text)
+      result.send(:set_subject, doc.root.elements['subject'].text)
+      result.send(:set_page_count, doc.root.elements['page_count'].text.to_i)
+      result.send(:set_page_width, doc.root.elements['width'].text.to_i)
+      result.send(:set_page_height, doc.root.elements['height'].text.to_i)
+      result.send(:set_file_size, doc.root.elements['file_size'].text.to_i)
+      result.send(:set_status, doc.root.elements['status'].text.to_i)
       return result
     end
-    # Uploads a file to Vuzit. It throws a Vuzit::Exception on failure.
-    #
-    # Example:
-    #
-    #  Vuzit::Service.public_key = 'YOUR_PUBLIC_API_KEY'
-    #  Vuzit::Service.private_key = 'YOUR_PRIVATE_API_KEY'
-    #
-    #  doc = Vuzit::Document.upload("c:/path/to/document.pdf", :secure => true)
-    #  puts doc.id
+    # Uploads a file to Vuzit. It throws a Vuzit::ClientException on failure.
     def self.upload(file, options = {})
       raise ArgumentError, "Options must be a hash" unless options.kind_of? Hash
-      timestamp = Time.now
-      sig = Vuzit::Service::get_signature('create', nil, timestamp)
-      # Make a request form
-      fields = Hash.new
-      fields[:format] = 'xml'
-      fields[:key] = Vuzit::Service::public_key
-      if options[:secure] != nil
-        fields[:secure] = options[:secure] == true ? '1' : '0'
-      else
-        fields[:secure] = '1'
+      if !File.exists?(file)
+        raise Vuzit::ClientException.new("The file could not be found: #{file}")
       end
-      fields[:signature] = sig
-      fields[:timestamp] = timestamp.to_i
-      fields[:file_type] = options[:file_type]
+      params = post_parameters("create", options)
       response = nil
       File.open(file, "rb") do |f|
-        fields[:upload] = f
-        response = send_request 'create', fields
+        params[:upload] = f
+        response = send_request 'create', params
       end
-      debug(response.code + " " + response.message + "\n" + response.body)
       # TODO: check the response.code.to_i to make sure it's 201
       begin
         doc = REXML::Document.new(response.body)
       rescue Exception => ex
-        raise Vuzit::Exception.new("XML error: #{ex.message}")
+        raise Vuzit::ClientException.new("XML error: #{ex.message}")
       end
       if doc.root == nil
-        raise Vuzit::Exception.new("No response from server");
+        raise Vuzit::ClientException.new("No response from server");
       end
       code = doc.root.elements['code']
       if code != nil
-        raise Vuzit::Exception.new(doc.root.elements['msg'].text, code.text.to_i);
+        raise Vuzit::ClientException.new(doc.root.elements['msg'].text, code.text.to_i);
       end
       id = doc.root.elements['web_id']
       if id == nil
-        raise Vuzit::Exception.new("Unknown error occurred");
+        raise Vuzit::ClientException.new("Unknown error occurred");
       end
       result = Vuzit::Document.new
-      result.id = id.text
+      result.send(:set_id, id.text)
       return result
     end
     private
-    # Sends debug messages if activated
-    def self.debug(text)
-      $stderr.puts(text) if Vuzit::Service::debug == true
-    end
-    # Makes a HTTP POST.
-    def self.send_request(method, fields = {})
-      # See if method is given
-      raise ArgumentError, "Method should be given" if method.nil? || method.empty?
-      debug("** Remote method call: #{method}; fields: #{fields.inspect}")
-      # replace pesky hashes to prevent accidents
-      fields = fields.stringify_keys
-      # Complete fields with the method name
-      fields['method'] = method
-      fields.reject! { |k, v| v.nil? }
-      debug("** POST parameters: #{fields.inspect}")
-      # Create the connection
-      uri = URI.parse(Vuzit::Service.service_url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      # API methods can be SLOW.  Make sure this is set to something big to prevent spurious timeouts
-      http.read_timeout = 15 * 60
-      request = Net::HTTP::Post.new('/documents')
-      request.multipart_params = fields
-      tries = TRIES
-      begin
-        tries -= 1
-        res = http.request(request)
-      rescue Exception
-        $stderr.puts "Request encountered error, will retry #{tries} more."
-        if tries > 0
-          # Retrying several times with sleeps is recommended.
-          # This will prevent temporary downtimes at Scribd from breaking API applications
-          sleep(20)
-          retry
-        end
-        raise $!
-      end
-      return res
-    end
+    # Private setter methods so that you can set the internal variables but
+    # not allow the setting of the public methods.
+    def set_id(value) @id = value; end
+    def set_subject(value) @subject = value; end
+    def set_title(value) @title = value; end
+    def set_status(value) @status = value; end
+    def set_page_count(value) @page_count = value; end
+    def set_page_width(value) @page_width = value; end
+    def set_page_height(value) @page_height = value; end
+    def set_file_size(value) @file_size = value; end
   end
 end

data/lib/vuzitruby/service.rb CHANGED Viewed

@@ -47,7 +47,8 @@ module Vuzit
     @@public_key = nil
     @@private_key = nil
     @@service_url = 'http://vuzit.com'
-    @@debug = false
+    @@product_name = 'VuzitRuby Library 1.2.0'
+    @@user_agent = @@product_name
     # TODO: For all of the set variables do not allow nil values
@@ -75,50 +76,48 @@ module Vuzit
     # you are running Vuzit Enterprise on your own server.
     # The default value is "http://vuzit.com"
     def self.service_url=(value)
-      @@service_url = value
+      url = value.strip
+      if url[-1, 1] == '/'
+        raise Exception.new("Trailing slashes (/) in service URLs are invalid")
+      end
+      @@service_url = url
     end
     # Returns the URL of the Vuzit web service.
     def self.service_url
-      @@service_url
+      # Return clone so it does not change the orginal value
+      @@service_url.clone
     end
-    # Switch this to _true_ if you would like to see debug messages in the
-    # output.
-    def self.debug=(value)
-      @@debug = value
+    # Returns the User-Agent of the library.
+    def self.user_agent
+      @@user_agent
     end
-    # Returns whether debugging is turned on or off.
-    def self.debug
-      @@debug
+    # Sets the User-Agent of the library.
+    def self.user_agent=(value)
+      @@user_agent = "#{value} (#{@@product_name})"
     end
     # Returns The signature string.  NOTE: If you are going to use this
     # with the Vuzit Javascript API then the value must be encoded with the
-    # CGI.escape function.  See the Wiki example for more information:
-    #
-    #   http://wiki.github.com/vuzit/vuzitruby/code-samples
-    #
-    # Example:
-    #
-    #  timestamp = Time.now
-    #  sig = Vuzit::Service.get_signature("show", "DOCUMENT_ID", timestamp)
-    def self.get_signature(service, id = '', time = nil)
+    # CGI.escape function.  See the Wiki example for more information.
+    def self.signature(service, id = '', time = nil, pages = '', label = '')
       if Vuzit::Service.public_key == nil || Vuzit::Service.private_key == nil
-        raise Vuzit::Exception.new("The public_key or private_key variables are nil")
+        raise Vuzit::ClientException.new("The public_key or private_key variables are nil")
       end
       time = (time == nil) ? Time.now.to_i : time.to_i
       if @@public_key == nil
-        raise Vuzit::Exception.new("Vuzit::Service.public_key not set")
+        raise Vuzit::ClientException.new("Vuzit::Service.public_key not set")
       end
       if @@private_key == nil
-        raise Vuzit::Exception.new("Vuzit::Service.private_key not set")
+        raise Vuzit::ClientException.new("Vuzit::Service.private_key not set")
       end
-      msg = "#{service}#{id}#{@@public_key}#{time}"
+      msg = "#{service}#{id}#{@@public_key}#{time}#{pages}#{label}"
       hmac = hmac_sha1(@@private_key, msg)
       result = Base64::encode64(hmac).chomp

data/lib/vuzitruby.rb CHANGED Viewed

@@ -3,7 +3,8 @@ $:.unshift(File.dirname(__FILE__))
 # This prevents the "require 'some_gem'" error
 require 'rubygems'
+require 'vuzitruby/base'
 require 'vuzitruby/service'
 require 'vuzitruby/document'
-require 'vuzitruby/exception'
+require 'vuzitruby/client_exception'

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vuzitruby
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Brent Matzelle
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2009-03-30 00:00:00 -04:00
+date: 2009-10-26 00:00:00 -04:00
 default_executable: vuzitcl
 dependencies: []
@@ -25,8 +25,9 @@ files:
 - README
 - Rakefile
 - lib/vuzitruby.rb
+- lib/vuzitruby/base.rb
 - lib/vuzitruby/document.rb
-- lib/vuzitruby/exception.rb
+- lib/vuzitruby/client_exception.rb
 - lib/vuzitruby/service.rb
 has_rdoc: true
 homepage: http://vuzit.com/