RubyGems - docverter - Versions diffs - 0.0.1 - Mend

docverter 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

data/.gitignore +17 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +51 -0
data/Rakefile +9 -0
data/docverter.gemspec +23 -0
data/lib/docverter.rb +107 -0
data/lib/docverter/conversion.rb +142 -0
data/lib/docverter/json.rb +598 -0
data/lib/docverter/version.rb +3 -0
data/test/test_docverter.rb +164 -0
data/test/test_helper.rb +33 -0
metadata +108 -0

data/.gitignore ADDED Viewed

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in docverter-api.gemspec
+gemspec

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Pete Keen
+MIT License
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md ADDED Viewed

@@ -0,0 +1,51 @@
+# Docverter
+This is the official Docverter Ruby API.
+## Installation
+Add this line to your application's Gemfile:
+    gem 'docverter-api'
+And then execute:
+    $ bundle
+Or install it yourself as:
+    $ gem install docverter-api
+## Usage
+First, sign up for [Docverter](http://www.docverter.com) and get your API key.
+Set your API key before using any of the rest of the library:
+    Docverter.api_key = <API-KEY>
+In a Rails project, put this in an initializer.
+A few example conversions:
+    Docverter::Conversion.run("markdown", "html", "Some Content")
+    # => "<html><body><p>Some Content</p></body></html>"
+    Docverter::Conversion.run do |c|
+      c.from    = "markdown"
+      c.to      = "html"
+      c.content = "Some Content"
+      c.stylesheet = "stylesheet.css"
+      c.add_other_file "stylesheet.css"
+    end
+    # => '<html><head><link rel="stylesheet" media="print" href="stylesheet.css"></head><body><p>Some Content</p></body></html>'
+See the documentation for `Docverter::Conversion` for more details.
+## Contributing
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile ADDED Viewed

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+task :test do
+  ret = true
+  Dir["test/**/*.rb"].each do |f|
+    ret = ret && sh("ruby #{f}")
+  end
+  exit(ret)
+end

data/docverter.gemspec ADDED Viewed

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'docverter/version'
+Gem::Specification.new do |gem|
+  gem.name          = "docverter"
+  gem.version       = Docverter::VERSION
+  gem.authors       = ["Pete Keen"]
+  gem.email         = ["pete@docverter.com"]
+  gem.description   = %q{API for converting documents with the Docverter service}
+  gem.summary       = %q{API for converting documents with the Docverter service}
+  gem.homepage      = "http://www.docverter.com"
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency("rest-client", ["~>1.6.7"])
+  gem.add_development_dependency("mocha")
+  gem.add_development_dependency("shoulda")
+end

data/lib/docverter.rb ADDED Viewed

@@ -0,0 +1,107 @@
+require 'rest_client'
+require 'docverter/json'
+require "docverter/version"
+require "docverter/conversion"
+module Docverter
+  class AuthenticationError < StandardError; end
+  class APIConnectionError < StandardError; end
+  class APIError < StandardError; end
+  @@api_key = nil
+  @@base_url = "https://api.docverter.com/v1"
+  def self.api_key
+    @@api_key
+  end
+  def self.api_key=(key)
+    @@api_key = key
+  end
+  def self.api_url(path='')
+    u = URI(@@base_url + path)
+    key = self.api_key
+    raise AuthenticationError.new('No API key provided. (HINT: set your API key using "Docverter.api_key = <API-KEY>". You can find your API in the Docverter web interface. See http://www.docverter.com/api.html for details, or email pete@docverter.com if you have any questions.)') unless key
+    u.user = key
+    u.password = ''
+    u.to_s
+  end
+  def self.base_url=(url)
+    @@base_url = url
+  end
+  def self.reset
+    @@api_key = nil
+    @@override_url = nil
+  end
+  def self.request(method, url, params={}, headers={})
+    key = @@api_key
+    raise AuthenticationERror.new('No API key provided. (HINT: set your API key using "Docverter.api_key = <API-KEY>". You can find your API in the Docverter web interface. See http://www.docverter.com/api.html for details, or email pete@docverter.com if you have any questions.)') unless key
+    url = self.api_url(url)
+    headers = {
+      :user_agent => "Docverter/v1 RubyBindings/#{Docverter::VERSION}",
+      :content_type => "multipart/form-data"
+    }.merge(headers)
+    opts = {
+      :method => method,
+      :url => url,
+      :headers => headers,
+      :open_timeout => 30,
+      :payload => params,
+    }
+    begin
+      response = execute_request(opts)
+    rescue SocketError => e
+      self.handle_restclient_error(e)
+    rescue NoMethodError => e
+      # Work around RestClient bug
+      if e.message =~ /\WRequestFailed\W/
+        e = APIConnectionError.new('Unexpected HTTP response code')
+        self.handle_restclient_error(e)
+      else
+        raise
+      end
+    rescue RestClient::ExceptionWithResponse => e
+      if rcode = e.http_code and rbody = e.http_body
+        self.handle_api_error(rcode, rbody)
+      else
+        self.handle_restclient_error(e)
+      end
+    rescue RestClient::Exception, Errno::ECONNREFUSED => e
+      self.handle_restclient_error(e)
+    end
+    response.body
+  end
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
+  end
+  def self.handle_api_error(code, body)
+    obj = Docverter::OkJson.decode(body)
+    raise APIError.new("Docverter API Error: #{obj['error']} (status: #{code})")
+  end
+  def self.handle_restclient_error(e)
+    case e
+    when RestClient::ServerBrokeConnection, RestClient::RequestTimeout
+      message = "Could not connect to Docverter (#{@@api_base}).  Please check your internet connection and try again.  If this problem persists, you should let me know at pete@docverter.com."
+    when SocketError
+      message = "Unexpected error communicating when trying to connect to Docverter.  HINT: You may be seeing this message because your DNS is not working.  To check, try running 'host docverter.com' from the command line."
+    else
+      message = "Unexpected error communicating with Docverter.  If this problem persists, let me know at pete@docverter.com."
+    end
+    message += "\n\n(Network error: #{e.message})"
+    raise APIConnectionError.new(message)
+  end
+end

data/lib/docverter/conversion.rb ADDED Viewed

@@ -0,0 +1,142 @@
+require 'ostruct'
+module Docverter
+  # Public: An invalid conversion has been specified
+  class InvalidConversionError < StandardError; end
+  # Public: Convert documents using Docverter
+  #
+  # Examples
+  #
+  #    Docverter::Conversion.run("markdown", "html", "Some Content")
+  #    # => "<html><body><p>Some Content</p></body></html>"
+  #
+  #    Docverter::Conversion.run do |c|
+  #      c.from    = "markdown"
+  #      c.to      = "html"
+  #      c.content = "Some Content"
+  #      c.stylesheet = "stylesheet.css"
+  #      c.add_other_file "stylesheet.css"
+  #    end
+  #    # => '<html><head><link rel="stylesheet" media="print" href="stylesheet.css"></head><body><p>Some Content</p></body></html>'
+  #
+  class Conversion < OpenStruct
+    # Public: Run a conversion on Docverter
+    #
+    # from    - The format of the input text (optional)
+    # to      - The format of the output document (optional)
+    # content - The content to be converted (optional)
+    #
+    # Yields the initialized Conversion object
+    #
+    # Returns the converted document or a status hash if a callback_url has been specified
+    #
+    # Examples
+    #
+    #    Docverter::Conversion.run("markdown", "pdf", "Some Content")
+    #
+    #    Docverter::Conversion.run do |c|
+    #      c.from = "markdown"
+    #      c.to   = "pdf"
+    #      c.add_input_file("input.md")
+    #      c.stylesheet = "stylesheet.css"
+    #      c.add_other_file "stylesheet.css"
+    #    end
+    def self.run(from=nil, to=nil, content=nil)
+      obj = new(from, to, content)
+      if block_given?
+        yield obj
+      end
+      obj.convert
+    end
+    # Public: Get the status of a particular conversion
+    #
+    # id - The integer ID of a conversion as given by Docverter::Conversion#run in async mode
+    #
+    # Returns a status hash
+    def self.status(id)
+      OkJson.decode(Docverter.request(:get, "/status/#{id.to_i}"))
+    end
+    # Public: Pick up the converted document for a particular conversion
+    #
+    # id - The integer ID of a conversion as given by Docverter::Conversion#run in async mode
+    #
+    # Returns the converted document
+    def self.pickup(id)
+      Docverter.request(:get, "/pickup/#{id.to_i}")
+    end
+    # Public: Run a conversion on Docverter
+    #
+    # from    - The format of the input text (optional)
+    # to      - The format of the output document (optional)
+    # content - The content to be converted (optional)
+    #
+    # Can accept a block that will be passed the initialized Conversion object to allow
+    # more settings to be set before the conversion is run
+    #
+    # Returns a new Conversion object
+    def initialize(from=nil, to=nil, content=nil)
+      super(
+        :from => from,
+        :to => to,
+        :content => content,
+        :input_files => [],
+        :other_files => [],
+      )
+    end
+    # Public: Add an input file to the conversion
+    #
+    # path - The path to the file to add as an input file
+    def add_input_file(path)
+      self.input_files << File.open(path, "rb")
+    end
+    # Public: Add another file to the conversion
+    #
+    # path - The path to the file to add
+    def add_other_file(path)
+      self.other_files << File.open(path, "rb")
+    end
+    # Public: Run the conversion through Docverter
+    def convert
+      if input_files.length == 0 && content == nil
+        raise InvalidConversionError.new("Cannot convert without an input_file or content")
+      end
+      unless self.content.nil?
+        temp = Tempfile.new("temp")
+        temp.write self.content
+        temp.flush
+        self.add_input_file(temp.path)
+      end
+      response = Docverter.request(:post, "/convert", self.to_h)
+      if self.callback_url
+        OkJson.decode(response)
+      else
+        response
+      end
+    end
+    # Internal: Convert this conversion into a hash
+    def to_h
+      hash = {}
+      self.instance_variable_get(:@table).each do |field,value|
+        next if value.nil?
+        hash[field] = value
+      end
+      hash
+    end
+  end
+end

data/lib/docverter/json.rb ADDED Viewed

@@ -0,0 +1,598 @@
+# encoding: UTF-8
+#
+# Copyright 2011, 2012 Keith Rarick
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+# See https://github.com/kr/okjson for updates.
+require 'stringio'
+# Some parts adapted from
+# http://golang.org/src/pkg/json/decode.go and
+# http://golang.org/src/pkg/utf8/utf8.go
+module Docverter
+  module OkJson
+    extend self
+    # Decodes a json document in string s and
+    # returns the corresponding ruby value.
+    # String s must be valid UTF-8. If you have
+    # a string in some other encoding, convert
+    # it first.
+    #
+    # String values in the resulting structure
+    # will be UTF-8.
+    def decode(s)
+      ts = lex(s)
+      v, ts = textparse(ts)
+      if ts.length > 0
+        raise Error, 'trailing garbage'
+      end
+      v
+    end
+    # Parses a "json text" in the sense of RFC 4627.
+    # Returns the parsed value and any trailing tokens.
+    # Note: this is almost the same as valparse,
+    # except that it does not accept atomic values.
+    def textparse(ts)
+      if ts.length < 0
+        raise Error, 'empty'
+      end
+      typ, _, val = ts[0]
+      case typ
+      when '{' then objparse(ts)
+      when '[' then arrparse(ts)
+      else
+        raise Error, "unexpected #{val.inspect}"
+      end
+    end
+    # Parses a "value" in the sense of RFC 4627.
+    # Returns the parsed value and any trailing tokens.
+    def valparse(ts)
+      if ts.length < 0
+        raise Error, 'empty'
+      end
+      typ, _, val = ts[0]
+      case typ
+      when '{' then objparse(ts)
+      when '[' then arrparse(ts)
+      when :val,:str then [val, ts[1..-1]]
+      else
+        raise Error, "unexpected #{val.inspect}"
+      end
+    end
+    # Parses an "object" in the sense of RFC 4627.
+    # Returns the parsed value and any trailing tokens.
+    def objparse(ts)
+      ts = eat('{', ts)
+      obj = {}
+      if ts[0][0] == '}'
+        return obj, ts[1..-1]
+      end
+      k, v, ts = pairparse(ts)
+      obj[k] = v
+      if ts[0][0] == '}'
+        return obj, ts[1..-1]
+      end
+      loop do
+        ts = eat(',', ts)
+        k, v, ts = pairparse(ts)
+        obj[k] = v
+        if ts[0][0] == '}'
+          return obj, ts[1..-1]
+        end
+      end
+    end
+    # Parses a "member" in the sense of RFC 4627.
+    # Returns the parsed values and any trailing tokens.
+    def pairparse(ts)
+      (typ, _, k), ts = ts[0], ts[1..-1]
+      if typ != :str
+        raise Error, "unexpected #{k.inspect}"
+      end
+      ts = eat(':', ts)
+      v, ts = valparse(ts)
+      [k, v, ts]
+    end
+    # Parses an "array" in the sense of RFC 4627.
+    # Returns the parsed value and any trailing tokens.
+    def arrparse(ts)
+      ts = eat('[', ts)
+      arr = []
+      if ts[0][0] == ']'
+        return arr, ts[1..-1]
+      end
+      v, ts = valparse(ts)
+      arr << v
+      if ts[0][0] == ']'
+        return arr, ts[1..-1]
+      end
+      loop do
+        ts = eat(',', ts)
+        v, ts = valparse(ts)
+        arr << v
+        if ts[0][0] == ']'
+          return arr, ts[1..-1]
+        end
+      end
+    end
+    def eat(typ, ts)
+      if ts[0][0] != typ
+        raise Error, "expected #{typ} (got #{ts[0].inspect})"
+      end
+      ts[1..-1]
+    end
+    # Scans s and returns a list of json tokens,
+    # excluding white space (as defined in RFC 4627).
+    def lex(s)
+      ts = []
+      while s.length > 0
+        typ, lexeme, val = tok(s)
+        if typ == nil
+          raise Error, "invalid character at #{s[0,10].inspect}"
+        end
+        if typ != :space
+          ts << [typ, lexeme, val]
+        end
+        s = s[lexeme.length..-1]
+      end
+      ts
+    end
+    # Scans the first token in s and
+    # returns a 3-element list, or nil
+    # if s does not begin with a valid token.
+    #
+    # The first list element is one of
+    # '{', '}', ':', ',', '[', ']',
+    # :val, :str, and :space.
+    #
+    # The second element is the lexeme.
+    #
+    # The third element is the value of the
+    # token for :val and :str, otherwise
+    # it is the lexeme.
+    def tok(s)
+      case s[0]
+      when ?{  then ['{', s[0,1], s[0,1]]
+      when ?}  then ['}', s[0,1], s[0,1]]
+      when ?:  then [':', s[0,1], s[0,1]]
+      when ?,  then [',', s[0,1], s[0,1]]
+      when ?[  then ['[', s[0,1], s[0,1]]
+      when ?]  then [']', s[0,1], s[0,1]]
+      when ?n  then nulltok(s)
+      when ?t  then truetok(s)
+      when ?f  then falsetok(s)
+      when ?"  then strtok(s)
+      when Spc then [:space, s[0,1], s[0,1]]
+      when ?\t then [:space, s[0,1], s[0,1]]
+      when ?\n then [:space, s[0,1], s[0,1]]
+      when ?\r then [:space, s[0,1], s[0,1]]
+      else          numtok(s)
+      end
+    end
+    def nulltok(s);  s[0,4] == 'null'  ? [:val, 'null',  nil]   : [] end
+    def truetok(s);  s[0,4] == 'true'  ? [:val, 'true',  true]  : [] end
+    def falsetok(s); s[0,5] == 'false' ? [:val, 'false', false] : [] end
+    def numtok(s)
+      m = /-?([1-9][0-9]+|[0-9])([.][0-9]+)?([eE][+-]?[0-9]+)?/.match(s)
+      if m && m.begin(0) == 0
+        if m[3] && !m[2]
+          [:val, m[0], Integer(m[1])*(10**Integer(m[3][1..-1]))]
+        elsif m[2]
+          [:val, m[0], Float(m[0])]
+        else
+          [:val, m[0], Integer(m[0])]
+        end
+      else
+        []
+      end
+    end
+    def strtok(s)
+      m = /"([^"\\]|\\["\/\\bfnrt]|\\u[0-9a-fA-F]{4})*"/.match(s)
+      if ! m
+        raise Error, "invalid string literal at #{abbrev(s)}"
+      end
+      [:str, m[0], unquote(m[0])]
+    end
+    def abbrev(s)
+      t = s[0,10]
+      p = t['`']
+      t = t[0,p] if p
+      t = t + '...' if t.length < s.length
+      '`' + t + '`'
+    end
+    # Converts a quoted json string literal q into a UTF-8-encoded string.
+    # The rules are different than for Ruby, so we cannot use eval.
+    # Unquote will raise an error if q contains control characters.
+    def unquote(q)
+      q = q[1...-1]
+      a = q.dup # allocate a big enough string
+      rubydoesenc = false
+      # In ruby >= 1.9, a[w] is a codepoint, not a byte.
+      if a.class.method_defined?(:force_encoding)
+        a.force_encoding('UTF-8')
+        rubydoesenc = true
+      end
+      r, w = 0, 0
+      while r < q.length
+        c = q[r]
+        case true
+        when c == ?\\
+          r += 1
+          if r >= q.length
+            raise Error, "string literal ends with a \"\\\": \"#{q}\""
+          end
+          case q[r]
+          when ?",?\\,?/,?'
+            a[w] = q[r]
+            r += 1
+            w += 1
+          when ?b,?f,?n,?r,?t
+            a[w] = Unesc[q[r]]
+            r += 1
+            w += 1
+          when ?u
+            r += 1
+            uchar = begin
+              hexdec4(q[r,4])
+            rescue RuntimeError => e
+              raise Error, "invalid escape sequence \\u#{q[r,4]}: #{e}"
+            end
+            r += 4
+            if surrogate? uchar
+              if q.length >= r+6
+                uchar1 = hexdec4(q[r+2,4])
+                uchar = subst(uchar, uchar1)
+                if uchar != Ucharerr
+                  # A valid pair; consume.
+                  r += 6
+                end
+              end
+            end
+            if rubydoesenc
+              a[w] = '' << uchar
+              w += 1
+            else
+              w += ucharenc(a, w, uchar)
+            end
+          else
+            raise Error, "invalid escape char #{q[r]} in \"#{q}\""
+          end
+        when c == ?", c < Spc
+          raise Error, "invalid character in string literal \"#{q}\""
+        else
+          # Copy anything else byte-for-byte.
+          # Valid UTF-8 will remain valid UTF-8.
+          # Invalid UTF-8 will remain invalid UTF-8.
+          # In ruby >= 1.9, c is a codepoint, not a byte,
+          # in which case this is still what we want.
+          a[w] = c
+          r += 1
+          w += 1
+        end
+      end
+      a[0,w]
+    end
+    # Encodes unicode character u as UTF-8
+    # bytes in string a at position i.
+    # Returns the number of bytes written.
+    def ucharenc(a, i, u)
+      case true
+      when u <= Uchar1max
+        a[i] = (u & 0xff).chr
+        1
+      when u <= Uchar2max
+        a[i+0] = (Utag2 | ((u>>6)&0xff)).chr
+        a[i+1] = (Utagx | (u&Umaskx)).chr
+        2
+      when u <= Uchar3max
+        a[i+0] = (Utag3 | ((u>>12)&0xff)).chr
+        a[i+1] = (Utagx | ((u>>6)&Umaskx)).chr
+        a[i+2] = (Utagx | (u&Umaskx)).chr
+        3
+      else
+        a[i+0] = (Utag4 | ((u>>18)&0xff)).chr
+        a[i+1] = (Utagx | ((u>>12)&Umaskx)).chr
+        a[i+2] = (Utagx | ((u>>6)&Umaskx)).chr
+        a[i+3] = (Utagx | (u&Umaskx)).chr
+        4
+      end
+    end
+    def hexdec4(s)
+      if s.length != 4
+        raise Error, 'short'
+      end
+      (nibble(s[0])<<12) | (nibble(s[1])<<8) | (nibble(s[2])<<4) | nibble(s[3])
+    end
+    def subst(u1, u2)
+      if Usurr1 <= u1 && u1 < Usurr2 && Usurr2 <= u2 && u2 < Usurr3
+        return ((u1-Usurr1)<<10) | (u2-Usurr2) + Usurrself
+      end
+      return Ucharerr
+    end
+    def surrogate?(u)
+      Usurr1 <= u && u < Usurr3
+    end
+    def nibble(c)
+      case true
+      when ?0 <= c && c <= ?9 then c.ord - ?0.ord
+      when ?a <= c && c <= ?z then c.ord - ?a.ord + 10
+      when ?A <= c && c <= ?Z then c.ord - ?A.ord + 10
+      else
+        raise Error, "invalid hex code #{c}"
+      end
+    end
+    # Encodes x into a json text. It may contain only
+    # Array, Hash, String, Numeric, true, false, nil.
+    # (Note, this list excludes Symbol.)
+    # X itself must be an Array or a Hash.
+    # No other value can be encoded, and an error will
+    # be raised if x contains any other value, such as
+    # Nan, Infinity, Symbol, and Proc, or if a Hash key
+    # is not a String.
+    # Strings contained in x must be valid UTF-8.
+    def encode(x)
+      case x
+      when Hash    then objenc(x)
+      when Array   then arrenc(x)
+      else
+        raise Error, 'root value must be an Array or a Hash'
+      end
+    end
+    def valenc(x)
+      case x
+      when Hash    then objenc(x)
+      when Array   then arrenc(x)
+      when String  then strenc(x)
+      when Numeric then numenc(x)
+      when true    then "true"
+      when false   then "false"
+      when nil     then "null"
+      else
+        raise Error, "cannot encode #{x.class}: #{x.inspect}"
+      end
+    end
+    def objenc(x)
+      '{' + x.map{|k,v| keyenc(k) + ':' + valenc(v)}.join(',') + '}'
+    end
+    def arrenc(a)
+      '[' + a.map{|x| valenc(x)}.join(',') + ']'
+    end
+    def keyenc(k)
+      case k
+      when String then strenc(k)
+      else
+        raise Error, "Hash key is not a string: #{k.inspect}"
+      end
+    end
+    def strenc(s)
+      t = StringIO.new
+      t.putc(?")
+      r = 0
+      # In ruby >= 1.9, s[r] is a codepoint, not a byte.
+      rubydoesenc = s.class.method_defined?(:encoding)
+      while r < s.length
+        case s[r]
+        when ?"  then t.print('\\"')
+        when ?\\ then t.print('\\\\')
+        when ?\b then t.print('\\b')
+        when ?\f then t.print('\\f')
+        when ?\n then t.print('\\n')
+        when ?\r then t.print('\\r')
+        when ?\t then t.print('\\t')
+        else
+          c = s[r]
+          case true
+          when rubydoesenc
+            begin
+              c.ord # will raise an error if c is invalid UTF-8
+              t.write(c)
+            rescue
+              t.write(Ustrerr)
+            end
+          when Spc <= c && c <= ?~
+            t.putc(c)
+          else
+            n = ucharcopy(t, s, r) # ensure valid UTF-8 output
+            r += n - 1 # r is incremented below
+          end
+        end
+        r += 1
+      end
+      t.putc(?")
+      t.string
+    end
+    def numenc(x)
+      if ((x.nan? || x.infinite?) rescue false)
+        raise Error, "Numeric cannot be represented: #{x}"
+      end
+      "#{x}"
+    end
+    # Copies the valid UTF-8 bytes of a single character
+    # from string s at position i to I/O object t, and
+    # returns the number of bytes copied.
+    # If no valid UTF-8 char exists at position i,
+    # ucharcopy writes Ustrerr and returns 1.
+    def ucharcopy(t, s, i)
+      n = s.length - i
+      raise Utf8Error if n < 1
+      c0 = s[i].ord
+      # 1-byte, 7-bit sequence?
+      if c0 < Utagx
+        t.putc(c0)
+        return 1
+      end
+      raise Utf8Error if c0 < Utag2 # unexpected continuation byte?
+      raise Utf8Error if n < 2 # need continuation byte
+      c1 = s[i+1].ord
+      raise Utf8Error if c1 < Utagx || Utag2 <= c1
+      # 2-byte, 11-bit sequence?
+      if c0 < Utag3
+        raise Utf8Error if ((c0&Umask2)<<6 | (c1&Umaskx)) <= Uchar1max
+        t.putc(c0)
+        t.putc(c1)
+        return 2
+      end
+      # need second continuation byte
+      raise Utf8Error if n < 3
+      c2 = s[i+2].ord
+      raise Utf8Error if c2 < Utagx || Utag2 <= c2
+      # 3-byte, 16-bit sequence?
+      if c0 < Utag4
+        u = (c0&Umask3)<<12 | (c1&Umaskx)<<6 | (c2&Umaskx)
+        raise Utf8Error if u <= Uchar2max
+        t.putc(c0)
+        t.putc(c1)
+        t.putc(c2)
+        return 3
+      end
+      # need third continuation byte
+      raise Utf8Error if n < 4
+      c3 = s[i+3].ord
+      raise Utf8Error if c3 < Utagx || Utag2 <= c3
+      # 4-byte, 21-bit sequence?
+      if c0 < Utag5
+        u = (c0&Umask4)<<18 | (c1&Umaskx)<<12 | (c2&Umaskx)<<6 | (c3&Umaskx)
+        raise Utf8Error if u <= Uchar3max
+        t.putc(c0)
+        t.putc(c1)
+        t.putc(c2)
+        t.putc(c3)
+        return 4
+      end
+      raise Utf8Error
+    rescue Utf8Error
+      t.write(Ustrerr)
+      return 1
+    end
+    class Utf8Error < ::StandardError
+    end
+    class Error < ::StandardError
+    end
+    Utagx = 0x80 # 1000 0000
+    Utag2 = 0xc0 # 1100 0000
+    Utag3 = 0xe0 # 1110 0000
+    Utag4 = 0xf0 # 1111 0000
+    Utag5 = 0xF8 # 1111 1000
+    Umaskx = 0x3f # 0011 1111
+    Umask2 = 0x1f # 0001 1111
+    Umask3 = 0x0f # 0000 1111
+    Umask4 = 0x07 # 0000 0111
+    Uchar1max = (1<<7) - 1
+    Uchar2max = (1<<11) - 1
+    Uchar3max = (1<<16) - 1
+    Ucharerr = 0xFFFD # unicode "replacement char"
+    Ustrerr = "\xef\xbf\xbd" # unicode "replacement char"
+    Usurrself = 0x10000
+    Usurr1 = 0xd800
+    Usurr2 = 0xdc00
+    Usurr3 = 0xe000
+    Spc = ' '[0]
+    Unesc = {?b=>?\b, ?f=>?\f, ?n=>?\n, ?r=>?\r, ?t=>?\t}
+  end
+end

data/lib/docverter/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Docverter
+  VERSION = "0.0.1"
+end

data/test/test_docverter.rb ADDED Viewed

@@ -0,0 +1,164 @@
+require File.expand_path("../test_helper", __FILE__)
+class TestDocverter < Test::Unit::TestCase
+  def setup
+    Docverter.reset
+    @mock = mock
+    Docverter.mock_rest_client = @mock
+    Docverter.api_key = "test_key"
+  end
+  should "set api key" do
+    Docverter.api_key = "key"
+    assert_equal "key", Docverter.api_key
+  end
+  should "raise if no api key given" do
+    Docverter.api_key = nil
+    assert_raises(Docverter::AuthenticationError) do
+      Docverter.api_url
+    end
+  end
+  should "have default base url" do
+    assert_equal "https://test_key:@api.docverter.com/v1", Docverter.api_url
+  end
+  should "override base url" do
+    Docverter.base_url = "http://localhost:5000/v1"
+    assert_equal "http://test_key:@localhost:5000/v1", Docverter.api_url
+  end
+  context "Conversion" do
+    should "initialize with from, to, and content" do
+      conversion = Docverter::Conversion.new('markdown', 'html', 'content')
+      assert_equal "markdown", conversion.from
+      assert_equal "html", conversion.to
+      assert_equal "content", conversion.content
+      assert_equal [], conversion.input_files
+      assert_equal [], conversion.other_files
+    end
+    should "add an input file from a path" do
+      temp = Tempfile.new("foo")
+      conversion = Docverter::Conversion.new
+      conversion.add_input_file(temp.path)
+      assert_equal conversion.input_files[0].path, temp.path
+    end
+    should "add an other file from a path" do
+      temp = Tempfile.new("foo")
+      conversion = Docverter::Conversion.new
+      conversion.add_other_file(temp.path)
+      assert_equal conversion.other_files[0].path, temp.path
+    end
+    should "to_h" do
+      conversion = Docverter::Conversion.new("markdown", "pdf")
+      h = {
+        :from => "markdown",
+        :to => "pdf",
+        :input_files => [],
+        :other_files => [],
+      }
+      assert_equal h, conversion.to_h
+    end
+    should "make request" do
+      temp = Tempfile.new("foo")
+      @mock.expects(:post).with do |url, blah, params|
+        url == "https://test_key:@api.docverter.com/v1/convert" \
+        && params[:from] == 'markdown' \
+        && params[:to] == 'pdf' \
+        && params[:other_files] == [] \
+        && params[:input_files][0].path == temp.path
+      end.returns(test_response("blah"))
+      res = Docverter::Conversion.run do |c|
+        c.from = "markdown"
+        c.to = "pdf"
+        c.add_input_file(temp.path)
+      end
+      assert_equal "blah", res
+    end
+    should "make request with content" do
+      @mock.expects(:post).with do |url, blah, params|
+        url == "https://test_key:@api.docverter.com/v1/convert" \
+        && params[:from] == 'markdown' \
+        && params[:to] == 'pdf' \
+        && params[:other_files] == [] \
+        && params[:input_files][0].read == "Some Content"
+      end.returns(test_response("Some Content"))
+      res = Docverter::Conversion.run do |c|
+        c.from = "markdown"
+        c.to = "pdf"
+        c.content = "Some Content"
+      end
+      assert_equal "Some Content", res
+    end
+    should "make request with no input_files or content raises" do
+      assert_raises(Docverter::InvalidConversionError) do
+        Docverter::Conversion.run do |c|
+          c.from = "markdown"
+          c.to = "pdf"
+        end
+      end
+    end
+    should "make async request" do
+      temp = Tempfile.new("foo")
+      @mock.expects(:post).with do |url, blah, params|
+        url == "https://test_key:@api.docverter.com/v1/convert" \
+        && params[:from] == 'markdown' \
+        && params[:to] == 'pdf' \
+        && params[:other_files] == [] \
+        && params[:input_files][0].path == temp.path \
+        && params[:callback_url] == 'http://www.google.com'
+      end.returns(test_response('{"status": "pending", "id": 123}'))
+      res = Docverter::Conversion.run do |c|
+        c.from = "markdown"
+        c.to = "pdf"
+        c.callback_url = 'http://www.google.com'
+        c.add_input_file(temp.path)
+      end
+      expected = {'id' => 123, 'status' => 'pending'}
+      assert_equal expected, res
+    end
+    should "pickup" do
+      @mock.expects(:get).with("https://test_key:@api.docverter.com/v1/pickup/1", nil, {}).returns(test_response("foo"))
+      res = Docverter::Conversion.pickup(1)
+      assert_equal "foo", res
+    end
+    should "status" do
+      @mock.expects(:get).with("https://test_key:@api.docverter.com/v1/status/1", nil, {}).returns(test_response('{"status": "pending", "id": 1}'))
+      res = Docverter::Conversion.status(1)
+      expected = {"status" => "pending", "id" => 1}
+      assert_equal expected, res
+    end
+  end
+end

data/test/test_helper.rb ADDED Viewed

@@ -0,0 +1,33 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'docverter'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'tempfile'
+module Docverter
+  @mock_rest_client = nil
+  def self.mock_rest_client=(mock_client)
+    @mock_rest_client = mock_client
+  end
+  def self.execute_request(opts)
+    get_params = (opts[:headers] || {})[:params]
+    post_params = opts[:payload]
+    case opts[:method]
+    when :get then @mock_rest_client.get opts[:url], get_params, post_params
+    when :post then @mock_rest_client.post opts[:url], get_params, post_params
+    when :delete then @mock_rest_client.delete opts[:url], get_params, post_params
+    end
+  end
+end
+def test_response(body, code=200)
+  m = mock
+  m.instance_variable_set('@docverter_values', { :body => body, :code => code })
+  def m.body; @docverter_values[:body]; end
+  def m.code; @docverter_values[:code]; end
+  m
+end

metadata ADDED Viewed

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: docverter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease:
+platform: ruby
+authors:
+- Pete Keen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: API for converting documents with the Docverter service
+email:
+- pete@docverter.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- docverter.gemspec
+- lib/docverter.rb
+- lib/docverter/conversion.rb
+- lib/docverter/json.rb
+- lib/docverter/version.rb
+- test/test_docverter.rb
+- test/test_helper.rb
+homepage: http://www.docverter.com
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: API for converting documents with the Docverter service
+test_files:
+- test/test_docverter.rb
+- test/test_helper.rb
+has_rdoc: