heroku-api 0.1.0 → 0.1.1

data/lib/heroku/api/mock/config_vars.rb

@@ -9,7 +9,7 @@ module Heroku
         with_mock_app(mock_data, app) do
           mock_data[:config_vars][app].delete(key)
           {
-            :body   => Heroku::API::OkJson.encode(mock_data[:config_vars][app]),
+            :body   => Heroku::API::Mock.json_gzip(mock_data[:config_vars][app]),
             :status => 200
           }
         end
@@ -21,7 +21,7 @@ module Heroku
         app, _ = request_params[:captures][:path]
         with_mock_app(mock_data, app) do
           {
-            :body   => Heroku::API::OkJson.encode(mock_data[:config_vars][app]),
+            :body   => Heroku::API::Mock.json_gzip(mock_data[:config_vars][app]),
             :status => 200
           }
         end
@@ -35,7 +35,7 @@ module Heroku
           new_config_vars = request_params[:body]
           mock_data[:config_vars][app].merge!(new_config_vars)
           {
-            :body   => Heroku::API::OkJson.encode(mock_data[:config_vars][app]),
+            :body   => Heroku::API::Mock.json_gzip(mock_data[:config_vars][app]),
             :status => 200
           }
         end

data/lib/heroku/api/mock/domains.rb

@@ -29,7 +29,7 @@ module Heroku
         app, _ = request_params[:captures][:path]
         with_mock_app(mock_data, app) do |app_data|
           {
-            :body   => Heroku::API::OkJson.encode(mock_data[:domains][app]),
+            :body   => Heroku::API::Mock.json_gzip(mock_data[:domains][app]),
             :status => 200
           }
         end
@@ -54,12 +54,12 @@ module Heroku
               }
             end
             {
-              :body   => Heroku::API::OkJson.encode('domain' => domain),
+              :body   => Heroku::API::Mock.json_gzip('domain' => domain),
               :status => 201
             }
           else
             {
-              :body   => Heroku::API::OkJson.encode([["base","Please install the Custom Domains addon before adding domains to your app"]]),
+              :body   => Heroku::API::Mock.json_gzip([["base","Please install the Custom Domains addon before adding domains to your app"]]),
               :status => 422
             }
           end

data/lib/heroku/api/mock/keys.rb

@@ -26,7 +26,7 @@ module Heroku
       Excon.stub(:expects => 200, :method => :get, :path => %r{^/user/keys}) do |params|
         request_params, mock_data = parse_stub_params(params)
         {
-          :body   => Heroku::API::OkJson.encode(mock_data[:keys]),
+          :body   => Heroku::API::Mock.json_gzip(mock_data[:keys]),
           :status => 200
         }
       end

data/lib/heroku/api/mock/logs.rb

@@ -9,7 +9,7 @@ module Heroku
         with_mock_app(mock_data, app) do
           uuid = [SecureRandom.hex(4), SecureRandom.hex(2), SecureRandom.hex(2), SecureRandom.hex(2), SecureRandom.hex(6)].join('-')
           {
-            :body   => "https://logplex.heroku.com/sessions/#{uuid}?srv=#{Time.now.to_i}",
+            :body   => Heroku::API::Mock.gzip("https://logplex.heroku.com/sessions/#{uuid}?srv=#{Time.now.to_i}"),
             :status => 200
           }
         end

data/lib/heroku/api/mock/processes.rb

@@ -8,7 +8,7 @@ module Heroku
       app, _ = request_params[:captures][:path]
       with_mock_app(mock_data, app) do |app_data|
         {
-          :body   => Heroku::API::OkJson.encode(get_mock_processes(mock_data, app)),
+          :body   => Heroku::API::Mock.json_gzip(get_mock_processes(mock_data, app)),
           :status => 200
         }
       end
@@ -41,7 +41,7 @@ module Heroku
         }
         mock_data[:ps][app] << data
         {
-          :body   => Heroku::API::OkJson.encode(data),
+          :body   => Heroku::API::Mock.json_gzip(data),
           :status => 200,
         }
       end
@@ -68,7 +68,7 @@ module Heroku
           end
         end
         {
-          :body   => 'ok',
+          :body   => Heroku::API::Mock.gzip('ok'),
           :status => 200
         }
       end
@@ -105,18 +105,18 @@ module Heroku
               end
             end
             {
-              :body   => qty.to_s,
+              :body   => Heroku::API::Mock.gzip(qty.to_s),
               :status => 200
             }
           else
             {
-              :body   => Heroku::API::OkJson.encode('error' => "No such type as #{type}") ,
+              :body   => Heroku::API::Mock.json_gzip('error' => "No such type as #{type}") ,
               :status => 422
             }
           end
         else
           {
-            :body   => Heroku::API::OkJson.encode('error' => "That feature is not available on this app's stack"),
+            :body   => Heroku::API::Mock.json_gzip('error' => "That feature is not available on this app's stack"),
             :status => 422
           }
         end
@@ -132,12 +132,12 @@ module Heroku
         type  = request_params[:query].has_key?('type') && request_params[:query]['type']
         if !ps && !type
           {
-            :body   => Heroku::API::OkJson.encode({'error' => 'Missing process argument'}),
+            :body   => Heroku::API::Mock.json_gzip({'error' => 'Missing process argument'}),
             :status => 422
           }
         else
           {
-            :body   => 'ok',
+            :body   => Heroku::API::Mock.gzip('ok'),
             :status => 200
           }
         end
@@ -153,12 +153,12 @@ module Heroku
         unless app_data['stack'] == 'cedar'
           app_data['dynos'] = dynos
           {
-            :body   => Heroku::API::OkJson.encode({'name' => app, 'dynos' => dynos}),
+            :body   => Heroku::API::Mock.json_gzip({'name' => app, 'dynos' => dynos}),
             :status => 200
           }
         else
           {
-            :body   => Heroku::API::OkJson.encode({'error' => "For Cedar apps, use `heroku scale web=#{dynos}`"}),
+            :body   => Heroku::API::Mock.json_gzip({'error' => "For Cedar apps, use `heroku scale web=#{dynos}`"}),
             :status => 422
           }
         end
@@ -174,12 +174,12 @@ module Heroku
         unless app_data['stack'] == 'cedar'
           app_data['workers'] = workers
           {
-            :body   => Heroku::API::OkJson.encode({'name' => app, 'workers' => workers}),
+            :body   => Heroku::API::Mock.json_gzip({'name' => app, 'workers' => workers}),
             :status => 200
           }
         else
           {
-            :body   => Heroku::API::OkJson.encode({'error' => "For Cedar apps, use `heroku scale worker=#{workers}`"}),
+            :body   => Heroku::API::Mock.json_gzip({'error' => "For Cedar apps, use `heroku scale worker=#{workers}`"}),
             :status => 422
           }
         end

data/lib/heroku/api/mock/releases.rb

@@ -9,17 +9,17 @@ module Heroku
         with_mock_app(mock_data, app) do |app_data|
           if get_mock_app_addon(mock_data, app, 'releases:basic')
             {
-              :body   => mock_data[:releases][app][-2..-1],
+              :body   => Heroku::API::Mock.json_gzip(mock_data[:releases][app][-2..-1]),
               :status => 200
             }
           elsif get_mock_app_addon(mock_data, app, 'releases:advanced')
             {
-              :body   => mock_data[:releases][app],
+              :body   => Heroku::API::Mock.json_gzip(mock_data[:releases][app]),
               :status => 200
             }
           else
             {
-              :body   => Heroku::API::OkJson.encode({'error' => 'Please install the Release Management add-on to access release history'}),
+              :body   => Heroku::API::Mock.json_gzip({'error' => 'Please install the Release Management add-on to access release history'}),
               :status => 422
             }
           end
@@ -39,7 +39,7 @@ module Heroku
             end
             if release_data = releases.detect {|release| release['name'] == release_name}
               {
-                :body   => Heroku::API::OkJson.encode(release_data),
+                :body   => Heroku::API::Mock.json_gzip(release_data),
                 :status => 200
               }
             else
@@ -50,7 +50,7 @@ module Heroku
             end
           else
             {
-              :body   => Heroku::API::OkJson.encode({'error' => 'Please install the Release Management add-on to access release history'}),
+              :body   => Heroku::API::Mock.json_gzip({'error' => 'Please install the Release Management add-on to access release history'}),
               :status => 422
             }
           end
@@ -95,24 +95,24 @@ module Heroku
                 }
 
                 {
-                  :body   => release_data['name'],
+                  :body   => Heroku::API::Mock.gzip(release_data['name']),
                   :status => 200
                 }
               else
                 {
-                  :body   => Heroku::API::OkJson.encode({'error' => 'Cannot rollback to a release that had a different set of addons installed'}),
+                  :body   => Heroku::API::Mock.json_gzip({'error' => 'Cannot rollback to a release that had a different set of addons installed'}),
                   :status => 422
                 }
               end
             else
               {
-                :body   => 'Record not found.',
+                :body   => Heroku::API::Mock.gzip('Record not found.'),
                 :status => 404
               }
             end
           else
             {
-              :body   => Heroku::API::OkJson.encode({'error' => 'Please install the Release Management add-on to access release history'}),
+              :body   => Heroku::API::Mock.json_gzip({'error' => 'Please install the Release Management add-on to access release history'}),
               :status => 422
             }
           end

data/lib/heroku/api/mock/stacks.rb

@@ -34,10 +34,10 @@ module Heroku
         request_params, mock_data = parse_stub_params(params)
         app, _ = request_params[:captures][:path]
         with_mock_app(mock_data, app) do |app_data|
-          stack_data = STACKS.dup
+          stack_data = Marshal::load(Marshal.dump(STACKS))
           stack_data.detect {|stack| stack['name'] == app_data['stack']}['current'] = true
           {
-            :body   => Heroku::API::OkJson.encode(stack_data),
+            :body   => Heroku::API::Mock.json_gzip(stack_data),
             :status => 200
           }
         end
@@ -52,7 +52,7 @@ module Heroku
           if app_data['stack'] != 'cedar' && stack != 'cedar'
             if STACKS.map {|stack_data| stack_data['name']}.include?(stack)
               {
-                :body   => <<-BODY,
+                :body   => Heroku::API::Mock.gzip(<<-BODY),
 HTTP/1.1 200 OK
 -----> Preparing to migrate #{app}
        #{app_data['stack']} -> #{stack}
@@ -66,13 +66,13 @@ BODY
               }
             else
               {
-                :body   => Heroku::API::OkJson.encode('error' => 'Stack not found'),
+                :body   => Heroku::API::Mock.json_gzip('error' => 'Stack not found'),
                 :status => 404
               }
             end
           else
             {
-              :body   => Heroku::API::OkJson.encode('error' => 'Stack migration to/from Cedar is not available. Create a new app with --stack cedar instead.'),
+              :body   => Heroku::API::Mock.json_gzip('error' => 'Stack migration to/from Cedar is not available. Create a new app with --stack cedar instead.'),
               :status => 422
             }
           end

data/lib/heroku/api/mock/user.rb

@@ -0,0 +1,16 @@
+module Heroku
+  class API
+    module Mock
+
+      # stub GET /user
+      Excon.stub(:expects => 200, :method => :get, :path => %r{^/user}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        {
+          :body   => Heroku::API::Mock.gzip(File.read("#{File.dirname(__FILE__)}/cache/get_user.json")),
+          :status => 200
+        }
+      end
+
+    end
+  end
+end

data/lib/heroku/api/user.rb

@@ -0,0 +1,14 @@
+module Heroku
+  class API
+
+    # GET /user
+    def get_user
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/user"
+      )
+    end
+
+  end
+end

data/lib/heroku/api/vendor/okjson.rb

@@ -1,4 +1,6 @@
-# Copyright 2011 Keith Rarick
+# 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
@@ -30,7 +32,6 @@ module Heroku
     module OkJson
       extend self
 
-      class ParserError < ::StandardError; end
 
       # Decodes a json document in string s and
       # returns the corresponding ruby value.
@@ -44,7 +45,7 @@ module Heroku
         ts = lex(s)
         v, ts = textparse(ts)
         if ts.length > 0
-          raise Heroku::API::OkJson::ParserError, 'trailing garbage'
+          raise Error, 'trailing garbage'
         end
         v
       end
@@ -56,14 +57,15 @@ module Heroku
       # except that it does not accept atomic values.
       def textparse(ts)
         if ts.length < 0
-          raise Heroku::API::OkJson::ParserError, 'empty'
+          raise Error, 'empty'
         end
 
         typ, _, val = ts[0]
         case typ
         when '{' then objparse(ts)
         when '[' then arrparse(ts)
-        else valparse(ts)
+        else
+          raise Error, "unexpected #{val.inspect}"
         end
       end
 
@@ -72,7 +74,7 @@ module Heroku
       # Returns the parsed value and any trailing tokens.
       def valparse(ts)
         if ts.length < 0
-          raise Heroku::API::OkJson::ParserError, 'empty'
+          raise Error, 'empty'
         end
 
         typ, _, val = ts[0]
@@ -81,7 +83,7 @@ module Heroku
         when '[' then arrparse(ts)
         when :val,:str then [val, ts[1..-1]]
         else
-          raise Heroku::API::OkJson::ParserError, "unexpected #{val.inspect}"
+          raise Error, "unexpected #{val.inspect}"
         end
       end
 
@@ -117,11 +119,11 @@ module Heroku
 
 
       # Parses a "member" in the sense of RFC 4627.
-      # Returns the parsed value and any trailing tokens.
+      # Returns the parsed values and any trailing tokens.
       def pairparse(ts)
         (typ, _, k), ts = ts[0], ts[1..-1]
         if typ != :str
-          raise Heroku::API::OkJson::ParserError, "unexpected #{k.inspect}"
+          raise Error, "unexpected #{k.inspect}"
         end
         ts = eat(':', ts)
         v, ts = valparse(ts)
@@ -161,20 +163,20 @@ module Heroku
 
       def eat(typ, ts)
         if ts[0][0] != typ
-          raise Heroku::API::OkJson::ParserError, "expected #{typ} (got #{ts[0].inspect})"
+          raise Error, "expected #{typ} (got #{ts[0].inspect})"
         end
         ts[1..-1]
       end
 
 
-      # Sans s and returns a list of json tokens,
+      # 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 Heroku::API::OkJson::ParserError, "invalid character at #{s[0,10].inspect}"
+            raise Error, "invalid character at #{s[0,10].inspect}"
           end
           if typ != :space
             ts << [typ, lexeme, val]
@@ -187,7 +189,7 @@ module Heroku
 
       # Scans the first token in s and
       # returns a 3-element list, or nil
-      # if no such token exists.
+      # if s does not begin with a valid token.
       #
       # The first list element is one of
       # '{', '}', ':', ',', '[', ']',
@@ -241,7 +243,7 @@ module Heroku
       def strtok(s)
         m = /"([^"\\]|\\["\/\\bfnrt]|\\u[0-9a-fA-F]{4})*"/.match(s)
         if ! m
-          raise Heroku::API::OkJson::ParserError, "invalid string literal at #{abbrev(s)}"
+          raise Error, "invalid string literal at #{abbrev(s)}"
         end
         [:str, m[0], unquote(m[0])]
       end
@@ -258,10 +260,16 @@ module Heroku
 
       # 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 Heroku::API::OkJson::ParserError, an error if q contains control characters.
+      # 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]
@@ -269,7 +277,7 @@ module Heroku
           when c == ?\\
             r += 1
             if r >= q.length
-              raise Heroku::API::OkJson::ParserError, "string literal ends with a \"\\\": \"#{q}\""
+              raise Error, "string literal ends with a \"\\\": \"#{q}\""
             end
 
             case q[r]
@@ -286,7 +294,7 @@ module Heroku
               uchar = begin
                 hexdec4(q[r,4])
               rescue RuntimeError => e
-                raise Heroku::API::OkJson::ParserError, "invalid escape sequence \\u#{q[r,4]}: #{e}"
+                raise Error, "invalid escape sequence \\u#{q[r,4]}: #{e}"
               end
               r += 4
               if surrogate? uchar
@@ -299,16 +307,23 @@ module Heroku
                   end
                 end
               end
-              w += ucharenc(a, w, uchar)
+              if rubydoesenc
+                a[w] = '' << uchar
+                w += 1
+              else
+                w += ucharenc(a, w, uchar)
+              end
             else
-              raise Heroku::API::OkJson::ParserError, "invalid escape char #{q[r]} in \"#{q}\""
+              raise Error, "invalid escape char #{q[r]} in \"#{q}\""
             end
           when c == ?", c < Spc
-            raise Heroku::API::OkJson::ParserError, "invalid character in string literal \"#{q}\""
+            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
@@ -318,9 +333,36 @@ module Heroku
       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 Heroku::API::OkJson::ParserError, 'short'
+          raise Error, 'short'
         end
         (nibble(s[0])<<12) | (nibble(s[1])<<8) | (nibble(s[2])<<4) | nibble(s[3])
       end
@@ -354,7 +396,7 @@ module Heroku
         when ?a <= c && c <= ?z then c.ord - ?a.ord + 10
         when ?A <= c && c <= ?Z then c.ord - ?A.ord + 10
         else
-          raise Heroku::API::OkJson::ParserError, "invalid hex code #{c}"
+          raise Error, "invalid hex code #{c}"
         end
       end
 
@@ -362,32 +404,53 @@ module Heroku
       # 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.
-      # Values that cannot be represented, such as
-      # Nan, Infinity, Symbol, and Proc, are encoded
-      # as null, in accordance with ECMA-262, 5th ed.
       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 Symbol  then strenc(x.to_s)
         when true    then "true"
         when false   then "false"
         when nil     then "null"
-        else              "null"
+        else
+          raise Error, "cannot encode #{x.class}: #{x.inspect}"
         end
       end
 
 
       def objenc(x)
-        '{' + x.map{|k,v| encode(k) + ':' + encode(v)}.join(',') + '}'
+        '{' + x.map{|k,v| keyenc(k) + ':' + valenc(v)}.join(',') + '}'
       end
 
 
       def arrenc(a)
-        '[' + a.map{|x| encode(x)}.join(',') + ']'
+        '[' + 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
 
 
@@ -395,6 +458,10 @@ module Heroku
         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('\\"')
@@ -409,21 +476,13 @@ module Heroku
             case true
             when Spc <= c && c <= ?~
               t.putc(c)
-            when true
+            when rubydoesenc
+              u = c.ord
+              surrenc(t, u)
+            else
               u, size = uchardec(s, r)
               r += size - 1 # we add one more at the bottom of the loop
-              if u < 0x10000
-                t.print('\\u')
-                hexenc4(t, u)
-              else
-                u1, u2 = unsubst(u)
-                t.print('\\u')
-                hexenc4(t, u1)
-                t.print('\\u')
-                hexenc4(t, u2)
-              end
-            else
-              # invalid byte; skip it
+              surrenc(t, u)
             end
           end
           r += 1
@@ -433,6 +492,20 @@ module Heroku
       end
 
 
+      def surrenc(t, u)
+        if u < 0x10000
+          t.print('\\u')
+          hexenc4(t, u)
+        else
+          u1, u2 = unsubst(u)
+          t.print('\\u')
+          hexenc4(t, u1)
+          t.print('\\u')
+          hexenc4(t, u2)
+        end
+      end
+
+
       def hexenc4(t, u)
         t.putc(Hex[(u>>12)&0xf])
         t.putc(Hex[(u>>8)&0xf])
@@ -442,9 +515,9 @@ module Heroku
 
 
       def numenc(x)
-        if x.nan? || x.infinite?
-          return 'null'
-        end rescue nil
+        if ((x.nan? || x.infinite?) rescue false)
+          raise Error, "Numeric cannot be represented: #{x}"
+        end
         "#{x}"
       end
 
@@ -506,32 +579,10 @@ module Heroku
       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
+      class Error < ::StandardError
       end
 
+
       Utagx = 0x80 # 1000 0000
       Utag2 = 0xc0 # 1100 0000
       Utag3 = 0xe0 # 1110 0000