heroku-platform-api 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTQ3NDk4YzM0YjRjNGYwZmM5NmZkYTkzMjBmYTI2NjU5M2FkYTY2ZQ==
+  data.tar.gz: !binary |-
+    NGVhZmFmYjZlOWExNDNiNDRhOGY5Y2I5ZDI2N2I5NWRmMjdhMTNiNA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    OTY5YWYxOWQ5Y2RiYmMwOWEzMDZkM2FjYmZjY2JhMWY1N2NhNjA1NTg5NmRl
+    OWIxNDJmMTY0ZDIxYWJkOGNmZjRmNzBlMmFhOWQ5MWUxODc0NjBlNmQ0NjQw
+    OWZhMmM4YWZiY2RmMDg4NWQ3NGU3OTRjZjc0YWNkYTAwY2U1OTA=
+  data.tar.gz: !binary |-
+    YTUyYjg1NTY5NWM2YTM2M2YzYzAyNGNkMDY1OGI5YzZjMjc1NTM5YWI4MGE5
+    YWUzY2RkNDc2MjdkMjU4YzE1OWMwZWQ3NTE4NjI3NDhhYzYxNGQwMjBlNGUz
+    YTJhNjNlZjY0NDljYzQ0OTQ5NDE0M2U5ZGY3MDYzNzU0ZThhY2Y=

data/.gitignore

@@ -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/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ashok Menon
+
+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

@@ -0,0 +1,141 @@
+# Heroku
+
+Create, destroy and manage your heroku applications programmatically, using the Heroku Platform API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'heroku-platform-api'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install heroku-platform-api
+
+## Usage
+
+### Require the gem
+
+    require 'heroku_api'
+    # => true
+
+### Configuration
+
+    Heroku::API.configure do |c|
+      c.api_key = "<Heroku API token>" # Mandatory
+      c.logger  = Logger.new($stdout)  # Optional
+    end
+
+### Apps
+
+The `Heroku::API.apps` object can be treated as though it were an `Array` of applications
+with the below methods added.
+
+#### Creating a new App
+
+    app = Heroku::API.apps.new(name: "example", region: {name: 'us'}, stack: 'cedar')
+    # => #<Heroku::Model::App id="01234567-89ab-cdef-0123-456789abcdef", name="example">
+
+All the parameters provided are optional, if this end-point is called without them,
+then defaults will be chosen.
+
+#### Listing all Available Apps
+
+    Heroku::API.apps.all
+    # => [#<Heroku::Model App...>,...]
+
+#### Searching for a Particular App
+
+    Heroku::API.apps["example"]
+    # => #<Heroku::Model::App id="01234567-89ab-cdef-0123-456789abcdef", name="example">
+
+OR
+
+    Heroku::API.apps.app("example")
+    # => #<Heroku::Model::App id="01234567-89ab-cdef-0123-456789abcdef", name="example">
+
+#### Updating an Existing App
+
+    app.name = "my_app" # Name and heroku based sub-domain of app.
+    app.maintenance = true # Maintenance mode on.
+    app.save
+    # => #<Heroku::Model::App id="01234567-89ab-cdef-0123-456789abcdef", name="my_app">
+
+#### Pushing to an Existing App
+
+This gem provides rudimentary support for pushing a given git repo to be deployed
+as the app, by simplying providing the directory of the repo:
+
+    app.push("path/to/repository")
+    # => true
+
+### Account
+
+#### Getting the account details
+
+    acc = Heroku::API.account
+    # => #<Heroku::Model::Account id="01234567-89ab-cdef-0123-456789abcdef", email="username@example.com">
+
+#### Updating the account details
+
+    acc.email = "joe-bloggs@example.com"
+    acc.allow_tracking = false # Let third party tracking services track you.
+    acc.save
+    # => #<Heroku::Model::Account id="01234567-89ab-cdef-0123-456789abcdef", email="joe-bloggs@example.com">
+
+#### Changing the account password
+
+    acc.update_password("new_password", "old_password")
+    # => true
+
+OR
+
+    Heroku::API.update_password("new_password", "old_password")
+    # => true
+
+### Rate Limits
+
+You can check the number of requests left like so:
+
+    Heroku::API.account.rate_limits
+    # => 1200
+
+OR
+
+    Heroku::API.rate_limits
+    # => 1200
+
+### Regions
+
+Find out the available regions with:
+
+    Heroku::API.regions
+    # => [{"created_at"=>"2012-11-21T21:44:16Z", "description"=>"United States", "id"=>"59accabd-516d-4f0e-83e6-6e3757701145", "name"=>"us", "updated_at"=>"2013-04-05T10:13:06Z"}, {"created_at"=>"2012-11-21T22:05:26Z", "description"=>"Europe", "id"=>"ed30241c-ed8c-4bb6-9714-61953675d0b4", "name"=>"eu", "updated_at"=>"2013-04-05T07:07:28Z"}]
+
+### Further API endpoints
+
+The Heroku Platform API Gem does not currently support any further API end-points
+natively. If you would like to add them, feel free to contribute, as directed below.
+
+If you would like to test the various endpoints that are not currently fully
+supported, please use the `Heroku::Conn` class, which will return the requested
+data as Ruby Arrays and Hashes:
+
+*Raw request for rate limit*
+
+    etag, response = Heroku::Conn::Get('/account/rate-limits'); response
+    # => { 'remaining' => '1200' }
+
+For further information, visit the [Heroku Platform API](https://devcenter.heroku.com/articles/platform-api-reference).
+
+## 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

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/heroku.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'heroku/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "heroku-platform-api"
+  spec.version       = Heroku::VERSION
+  spec.authors       = ["Ashok Menon", "Rentify"]
+  spec.email         = ["amenon94@gmail.com", "dev@rentify.com"]
+  spec.description   = %q{Create, destroy and manage your heroku applications programmatically, using the Heroku Platform API.}
+  spec.summary       = %q{Ruby client for the Heroku Platform API.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "git"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/heroku/api.rb

@@ -0,0 +1,19 @@
+require 'heroku/properties'
+
+module Heroku
+  class API
+    require 'heroku/api/account'
+    require 'heroku/api/password'
+    require 'heroku/api/rate_limits'
+    require 'heroku/api/regions'
+    require 'heroku/api/apps'
+    require 'heroku/api/app'
+
+    extend Heroku::Properties::ConfigMethods
+    extend Heroku::API::Account
+    extend Heroku::API::Password
+    extend Heroku::API::RateLimits
+    extend Heroku::API::Regions
+    extend Heroku::API::Apps
+  end
+end

data/lib/heroku/api/account.rb

@@ -0,0 +1,38 @@
+require 'heroku/conn'
+require 'heroku/properties'
+require 'heroku/model/account'
+
+module Heroku
+  class API
+    module Account
+      @@etag        = nil
+      RESOURCE_TYPE = "ACCOUNT"
+
+      def account
+        Heroku::Properties.logger.info("[Account] Fetching.")
+
+        @@etag, res =
+          Heroku::Conn::Get(
+            '/account',
+            etag: @@etag,
+            r_type: RESOURCE_TYPE
+          )
+
+        Heroku::Model::Account.new(res.merge("parent" => self))
+      end
+
+      def update_account(account)
+        Heroku::Properties.logger.info("[Account] Updating #{account.id}")
+
+        @@etag, res =
+          Heroku::Conn::Patch(
+            "/account",
+            r_type: RESOURCE_TYPE,
+            body: account.patchable.to_json
+          )
+
+        Heroku::Model::Account.new(res.merge("parent" => self))
+      end
+    end
+  end
+end

data/lib/heroku/api/app.rb

@@ -0,0 +1,61 @@
+require 'heroku/conn'
+require 'heroku/properties'
+require 'heroku/model/app'
+
+module Heroku
+  class API
+    module App
+      @@etags       = {}
+      RESOURCE_TYPE = "APP"
+
+      def app(name_or_id)
+        Heroku::Properties.logger.info("[App] Fetching #{name_or_id}")
+
+        etag, res =
+          Heroku::Conn::Get(
+            "/apps/#{name_or_id}",
+            etag: @@etags[name_or_id],
+            r_type: RESOURCE_TYPE
+          )
+
+        @@etags[res['id']]   = etag
+        @@etags[res['name']] = etag
+        Heroku::Model::App.new(res.merge("parent" => self))
+      end
+
+      def new(params = {})
+        Heroku::Properties.logger.info("[App] New with parameters: #{params.inspect}")
+
+        _, res =
+          Heroku::Conn::Post(
+            '/apps',
+            r_type: RESOURCE_TYPE,
+            body: params.to_json
+          )
+
+        Heroku::Model::App.new(res.merge("parent" => self))
+      end
+
+      def update_app(app)
+        Heroku::Properties.logger.info("[App] Updating #{app.id}")
+
+        etag, res =
+          Heroku::Conn::Patch(
+            app.end_point,
+            r_type: RESOURCE_TYPE,
+            body: app.patchable.to_json
+          )
+
+        @@etags[res['id']]   = etag
+        @@etags[res['name']] = etag
+        Heroku::Model::App.new(res.merge("parent" => self))
+      end
+
+      def delete_app(app)
+        Heroku::Properties.logger.info("[App] Deleting #{app.id}")
+        Heroku::Conn::Delete(app.end_point, r_type: RESOURCE_TYPE)
+        true
+      end
+    end
+  end
+end

data/lib/heroku/api/apps.rb

@@ -0,0 +1,31 @@
+require 'heroku/conn'
+require 'heroku/properties'
+require 'heroku/model/app_list'
+require 'heroku/model/app'
+
+module Heroku
+  class API
+    module Apps
+      @@etag        = nil
+      RESOURCE_TYPE = "APPS"
+
+      def apps
+        Heroku::Model::AppList.new( ->(parent){
+          Heroku::Properties.logger.info("[Apps] Fetching")
+
+          @@etag, res =
+            Heroku::Conn::Get(
+              "/apps",
+              etag: @@etag,
+              r_type: RESOURCE_TYPE
+            )
+
+          res.map do |params|
+            Heroku::Model::App.new(params.merge("parent" => parent))
+          end
+        })
+      end
+
+    end
+  end
+end

data/lib/heroku/api/password.rb

@@ -0,0 +1,18 @@
+require 'heroku/conn'
+require 'heroku/properties'
+
+module Heroku
+  class API
+    module Password
+      def update_password(new_password, current_password)
+        Heroku::Properties.logger.info("[Password] Updating")
+
+        Heroku::Conn::Put("/account/password", body: {
+          password:             new_password,
+          current_password: current_password
+        }.to_json)
+        true
+      end
+    end
+  end
+end

data/lib/heroku/api/rate_limits.rb

@@ -0,0 +1,24 @@
+require 'heroku/conn'
+require 'heroku/properties'
+
+module Heroku
+  class API
+    module RateLimits
+      @@etag        = nil
+      RESOURCE_TYPE = "RATE_LIMITS"
+
+      def rate_limits
+        Heroku::Properties.logger.info("[Rate Limits] Fetching")
+
+        @@etag, res =
+          Heroku::Conn::Get(
+            "/account/rate-limits",
+            etag: @@etag,
+            r_type: RESOURCE_TYPE
+          )
+
+        res["remaining"].to_i
+      end
+    end
+  end
+end

data/lib/heroku/api/regions.rb

@@ -0,0 +1,13 @@
+require 'heroku/conn'
+require 'heroku/properties'
+
+module Heroku
+  class API
+    module Regions
+      def regions
+        Heroku::Properties.logger.info("[Regions] Fetching")
+        Heroku::Conn::Get("/regions").last
+      end
+    end
+  end
+end

data/lib/heroku/conn.rb

@@ -0,0 +1,91 @@
+require 'json'
+require 'net/http'
+require 'heroku/properties'
+
+module Heroku
+  class Conn
+    require 'heroku/conn/cache'
+
+    APIRequest = Struct.new(:method, :end_point)
+
+    @https = Net::HTTP.new('api.heroku.com', 443).tap do |https|
+      https.use_ssl = true
+    end
+
+    def self.cache
+      @cache ||= Heroku::Conn::Cache.new
+    end
+
+    def self.method_missing(method, end_point, opts = {})
+      _Request = Net::HTTP.const_get(method.capitalize)
+
+      req      = _Request.new(end_point, headers(opts))
+      req.body = opts[:body]
+      api_req  = APIRequest[method, end_point]
+
+      Heroku::Properties.logger.debug("[Conn] Attempting #{method.upcase} #{end_point} ...")
+
+      check_response(api_req, opts[:r_type], @https.request(req))
+    end
+
+  private
+
+    def self.check_response(api_req, r_type, res)
+      Heroku::Properties.logger.debug("[Conn] Received #{res.code} for #{r_type} at #{api_req.end_point}")
+
+      case res
+      when Net::HTTPOK,
+           Net::HTTPCreated
+        cache.put(
+          r_type, res["ETag"],
+          JSON.parse(res.body)
+        )
+      when Net::HTTPPartialContent
+        cache.put(
+          r_type, res["ETag"],
+          gather_partial_content(api_req, res)
+        )
+      when Net::HTTPNotModified then cache.fetch(r_type, res["ETag"])
+      when Net::HTTPSuccess     then [res["ETag"], JSON.parse(res.body)]
+      else                           raise_exception(res)
+      end
+    end
+
+    def gather_partial_content(api_req, res)
+      Heroku::Properties.logger.info("[Conn] Gathering Partial Content.")
+
+      list_head = JSON.parse(res.body)
+      etag, list_tail =
+        self.send(
+          api_req.method,
+          api_req.end_point,
+          range: res["Next-Range"]
+        )
+
+      list_tail.unshift(*list_head)
+    end
+
+    def self.raise_exception(res)
+      Heroku::Properties.logger.error("[Conn] Uh oh, something went wrong with request #{res["Request-Id"]}.")
+      raise res.class::EXCEPTION_TYPE.new(status(res.code), nil)
+    end
+
+    def self.status(code)
+      Hash[Net::HTTPResponse::CODE_TO_OBJ.map { |k, v| [k, v.to_s] }]
+        .merge({ "429" => "Net::HTTPTooManyRequests" }) # Ruby 1.9.3 shiv
+        .fetch(code, "Net::HTTPUnknownError")
+    end
+
+    def self.headers(opts = {})
+      {
+        "Accept"        => 'application/vnd.heroku+json; version=3',
+        "Content-Type"  => 'application/json',
+        "Authorization" => Heroku::Properties.auth_token,
+        "User-Agent"    => Heroku::Properties::USER_AGENT
+      }.merge({}.tap do |header|
+        header["If-None-Match"] = opts[:etag]  if opts[:etag]
+        header["Range"]         = opts[:range] if opts[:range]
+      end)
+    end
+  end
+end

data/lib/heroku/conn/cache.rb

@@ -0,0 +1,47 @@
+require 'heroku/properties'
+
+class Heroku::Conn::Cache
+  CachePair = Struct.new(:response, :etag)
+
+  def initialize()
+    @response_cache = {}
+    @etag_pointers  = {}
+  end
+
+  def put(r_type, new_etag, json)
+    pair        = pair(r_type)
+    key         = key(json)
+    old_etag, _ = pair.response[key]
+    record      = [new_etag, json]
+
+    Heroku::Properties.logger.debug("[#{r_type} Cache] Caching #{key}    #{new_etag}")
+    Heroku::Properties.logger.debug("[#{r_type} Cache] Dissociating tag: #{old_etag}")
+
+    pair.etag.delete(old_etag)
+    pair.response[key]  = record
+    pair.etag[new_etag] = record
+    record
+  end
+
+  def fetch(r_type, etag)
+    Heroku::Properties.logger.info("[#{r_type} Cache] Fetching #{etag}")
+    pair(r_type).etag[etag]
+  end
+
+private
+
+  def pair(r_type)
+    CachePair[
+      @response_cache[r_type] ||= {},
+      @etag_pointers[r_type]  ||= {}
+    ]
+  end
+
+  def key(json_response)
+    case json_response
+    when Array then "list"
+    when Hash  then json_response['id']
+    else            nil
+    end
+  end
+end

data/lib/heroku/model.rb

@@ -0,0 +1,9 @@
+module Heroku
+  module Model
+    require 'heroku/model/model_helper'
+    require 'heroku/model/array_proxy'
+    require 'heroku/model/account'
+    require 'heroku/model/app_list'
+    require 'heroku/model/app'
+  end
+end

data/lib/heroku/model/account.rb

@@ -0,0 +1,45 @@
+require 'heroku/api/password'
+require 'heroku/api/rate_limits'
+require 'heroku/model/model_helper'
+
+module Heroku
+  module Model
+    class Account < Struct.new(
+      :parent,
+      :id,
+      :email,
+      :verified,
+      :allow_tracking,
+      :beta,
+      :last_login,
+      :updated_at,
+      :created_at
+    )
+
+      include Heroku::Model::ModelHelper
+      include Heroku::API::Password
+      include Heroku::API::RateLimits
+
+      def inspect
+        "#<#{self.class.name} #{identifier}>"
+      end
+
+      def initialize(params = {})
+        super(*struct_init_from_hash(params))
+      end
+
+      def patchable
+        sub_struct_as_hash(:email, :allow_tracking)
+      end
+
+      def identifiable
+        sub_struct_as_hash(:id, :email)
+      end
+
+      def save
+        parent.update_account(self)
+      end
+
+    end
+  end
+end

data/lib/heroku/model/app.rb

@@ -0,0 +1,70 @@
+require 'heroku/model/model_helper'
+require 'git'
+
+module Heroku
+  module Model
+    class App < Struct.new(
+      :parent,
+      :id,
+      :name,
+      :owner,
+      :region,
+      :git_url,
+      :web_url,
+      :repo_size,
+      :slug_size,
+      :buildpack_provided_description,
+      :stack,
+      :maintenance,
+      :archived_at,
+      :created_at,
+      :released_at,
+      :updated_at
+    )
+
+      include Heroku::Model::ModelHelper
+
+      def inspect
+        "#<#{self.class.name} #{identifier}>"
+      end
+
+      def initialize(params = {})
+        super(*struct_init_from_hash(params))
+      end
+
+      def push(dir)
+        begin
+          Git.open(dir, log: Heroku::Properties.logger).push(git_url)
+          true
+        rescue => e
+          Heroku::Properties.logger.error(e.message)
+          e.backtrace.each do |line|
+            Heroku::Properties.logger.error(line)
+          end
+
+          false
+        end
+      end
+
+      def patchable
+        sub_struct_as_hash(:maintenance, :name)
+      end
+
+      def identifiable
+        sub_struct_as_hash(:id, :name)
+      end
+
+      def end_point
+        "/apps/#{id}"
+      end
+
+      def save
+        parent.update_app(self)
+      end
+
+      def destroy
+        parent.delete_app(self)
+      end
+    end
+  end
+end

data/lib/heroku/model/app_list.rb

@@ -0,0 +1,21 @@
+require 'heroku/api/app'
+require 'heroku/model/array_proxy'
+
+module Heroku
+  module Model
+    class AppList < Heroku::Model::ArrayProxy
+      include Heroku::API::App
+
+      def inspect
+        "#<Heroku::Model::Apps>"
+      end
+
+      def [](key)
+        case key
+        when String, Symbol then app(key.to_s)
+        else                     super(key)
+        end
+      end
+    end
+  end
+end

data/lib/heroku/model/array_proxy.rb

@@ -0,0 +1,27 @@
+module Heroku
+  module Model
+    class ArrayProxy
+      def initialize(deferred_array)
+        @deferred_array = deferred_array
+      end
+
+      def method_missing(sym, *args)
+        begin
+          proxy_array.send(sym, *args)
+        rescue NoMethodError
+          super
+        end
+      end
+
+      def all
+        proxy_array
+      end
+
+    protected
+
+      def proxy_array
+        @proxy_array ||= @deferred_array.call(self)
+      end
+    end
+  end
+end

data/lib/heroku/model/model_helper.rb

@@ -0,0 +1,17 @@
+module Heroku
+  module Model
+    module ModelHelper
+      def struct_init_from_hash(hash)
+        hash.values_at(*members.map(&:to_s))
+      end
+
+      def sub_struct_as_hash(*params)
+        Hash[(params & members).map { |k| [k, send(k)] }]
+      end
+
+      def identifier
+        identifiable.to_a.map { |k,v| "#{k}=#{v.inspect}"}.join(', ')
+      end
+    end
+  end
+end

data/lib/heroku/properties.rb

@@ -0,0 +1,36 @@
+require 'base64'
+require 'heroku/version'
+
+module Heroku
+  class Properties
+    require 'heroku/properties/null_logger'
+
+    USER_AGENT   = "Heroku Platform API Gem #{Heroku::VERSION}"
+    @@auth_token = nil
+    @@logger     = nil
+
+    def self.auth_token
+      @@auth_token
+    end
+
+    def self.api_key=(key)
+      raise ArgumentError, "Need an API key" if key.nil?
+      @@auth_token = Base64.strict_encode64(":#{key}\n").strip
+      key
+    end
+
+    def self.logger
+      @@logger || NullLogger.new
+    end
+
+    def self.logger=(logger)
+      @@logger = logger
+    end
+
+    module ConfigMethods
+      def configure # yield
+        yield Heroku::Properties
+      end
+    end
+  end
+end

data/lib/heroku/properties/null_logger.rb

@@ -0,0 +1,16 @@
+module Heroku
+  class Properties
+    class NullLogger
+
+      def info(   msg); end
+      def warn(   msg); end
+      def debug(  msg); end
+      def unknown(msg); end
+
+      def tagged(tag) # yields
+        yield
+      end
+
+    end
+  end
+end

data/lib/heroku/version.rb

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

data/lib/heroku_api.rb

@@ -0,0 +1,6 @@
+module Heroku
+  require 'heroku/properties'
+  require 'heroku/conn'
+  require 'heroku/model'
+  require 'heroku/api'
+end

data/spec/heroku/conn/cache_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Heroku::Conn::Cache do
+  subject { Heroku::Conn::Cache.new }
+
+  describe "#put" do
+    let(:new_etag) { "new_etag" }
+    let(:old_etag) { "old_etag" }
+    let(:r_type)   { "test" }
+    let(:json)     { { a: 1 } }
+    let(:new_json) { { a: 2 } }
+
+    before do
+      subject.put(r_type, old_etag, json)
+    end
+
+    it "should update the cache value" do
+      subject.put(r_type, new_etag, new_json)
+      expect(subject.fetch(r_type, new_etag)).to eq([new_etag, new_json])
+    end
+
+    it "should remove references to the old etag." do
+      subject.put(r_type, new_etag, new_json)
+
+      expect(subject.fetch(r_type, old_etag)).to be_nil
+    end
+  end
+
+end

data/spec/heroku/conn_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Heroku::Conn do
+
+  describe ".check_response" do
+    context "when the response is unsuccessful" do
+      let(:unsuccessful_response) { Net::HTTPClientError.new() }
+
+      it "should raise a error" do
+        expect { described_class.send(:check_response, nil, nil, response) }.to raise_error
+      end
+    end
+  end
+end

data/spec/heroku/model/model_helper_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Heroku::Model::ModelHelper do
+  let(:_Model) do
+    Class.new(Struct.new(:a, :b, :c)) do
+      include Heroku::Model::ModelHelper
+    end
+  end
+
+  subject { _Model[1, 2, 3] }
+
+
+  describe "#struct_init_from_hash" do
+    let(:valid_hash)     { { "a" => 1, "b" => 2, "c" => 3 } }
+    let(:disorderd_hash) { { "b" => 2, "a" => 1, "c" => 3 }}
+    let(:invalid_hash)   { { "d" => 4 } }
+
+    it "finds all the values from the hash that are members of the Model." do
+      init_list = subject.struct_init_from_hash(valid_hash)
+      expect(init_list).to match_array([1, 2, 3])
+    end
+
+    it "provides the values in the Model's order, not the hash's." do
+      init_list = subject.struct_init_from_hash(disorderd_hash)
+      expect(init_list).to eq([1, 2, 3])
+    end
+
+    it "ignores values from the has that are not members of the Model." do
+      init_list = subject.struct_init_from_hash(invalid_hash)
+      expect(init_list).not_to include(4)
+    end
+  end
+
+  describe "#sub_struct_as_hash" do
+    let(:valid_params) { [:a, :b] }
+    let(:invalid_params) { [:d] }
+
+    it "returns a hash of the requisite parameters." do
+      hash = subject.sub_struct_as_hash(*valid_params)
+      expect(hash).to include(a: 1, b: 2)
+    end
+
+    it "does not include paramters that are not requested." do
+      hash = subject.sub_struct_as_hash(*valid_params)
+      expect(hash).not_to include(:c)
+    end
+
+    it "ignores parameters that do not exist." do
+      hash = subject.sub_struct_as_hash(*invalid_params)
+      expect(hash).not_to include(:d)
+    end
+  end
+
+  describe "#identifier" do
+    context "when there are no identifiable parameters" do
+      before { subject.should_receive(:identifiable).and_return({}) }
+      its(:identifier) { should == "" }
+    end
+
+    context "when the identifier is one parameter" do
+      before { subject.should_receive(:identifiable).and_return({ a: 1 }) }
+      its(:identifier) { should == "a=1" }
+    end
+
+    context "when the identifier contains multiple parameters" do
+      before { subject.should_receive(:identifiable).and_return({ a: 1, b: 2}) }
+      its(:identifier) { should == "a=1, b=2" }
+    end
+  end
+end

data/spec/heroku/properties/null_logger_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Heroku::Properties::NullLogger do
+
+  subject { described_class.new }
+
+  it { should respond_to(:unknown).with(1).argument }
+  it { should respond_to(:warn).with(1).argument }
+  it { should respond_to(:debug).with(1).argument }
+  it { should respond_to(:info).with(1).argument }
+
+  describe "#tagged" do
+    let(:block_check) { double("block_check", call: true) }
+
+    it { should respond_to(:tagged).with(1).argument }
+    it "calls the block provided to it" do
+      block_check.should_receive(:call).once
+
+      subject.tagged("tag") do
+        block_check.call
+      end
+    end
+  end
+
+end

data/spec/heroku/properties_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Heroku::Properties do
+
+  it "should respond to #auth_token" do
+    expect(described_class).to respond_to(:auth_token)
+  end
+
+  describe "#api_key=" do
+    let(:api_key) { "01234567-89ab-cdef-0123-456789abcdef" }
+
+    it "should create a base64 encoded auth token" do
+      described_class.api_key = api_key
+      expect(described_class.auth_token).to eq(Base64.encode64(":#{api_key}\n").strip)
+    end
+
+    context "when no api_key is provided" do
+      let(:api_key) { nil }
+
+      it "should raise an error" do
+        expect { described_class.api_key = api_key }.to raise_error(ArgumentError)
+      end
+
+      it "should leave the auth_token unchanged" do
+        expect {
+          begin
+            described_class.api_key = api_key
+          rescue ArgumentError
+          end
+        }.not_to change(described_class, :auth_token)
+      end
+    end
+  end
+
+  context "when no logger is provided" do
+    before do
+      described_class.logger = nil
+    end
+
+    it "should provide a null logger" do
+      expect(described_class.logger).not_to be_nil
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+Bundler.setup
+
+require 'heroku_api'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: heroku-platform-api
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ashok Menon
+- Rentify
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Create, destroy and manage your heroku applications programmatically,
+  using the Heroku Platform API.
+email:
+- amenon94@gmail.com
+- dev@rentify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- heroku.gemspec
+- lib/heroku/api.rb
+- lib/heroku/api/account.rb
+- lib/heroku/api/app.rb
+- lib/heroku/api/apps.rb
+- lib/heroku/api/password.rb
+- lib/heroku/api/rate_limits.rb
+- lib/heroku/api/regions.rb
+- lib/heroku/conn.rb
+- lib/heroku/conn/cache.rb
+- lib/heroku/model.rb
+- lib/heroku/model/account.rb
+- lib/heroku/model/app.rb
+- lib/heroku/model/app_list.rb
+- lib/heroku/model/array_proxy.rb
+- lib/heroku/model/model_helper.rb
+- lib/heroku/properties.rb
+- lib/heroku/properties/null_logger.rb
+- lib/heroku/version.rb
+- lib/heroku_api.rb
+- spec/heroku/conn/cache_spec.rb
+- spec/heroku/conn_spec.rb
+- spec/heroku/model/model_helper_spec.rb
+- spec/heroku/properties/null_logger_spec.rb
+- spec/heroku/properties_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Ruby client for the Heroku Platform API.
+test_files:
+- spec/heroku/conn/cache_spec.rb
+- spec/heroku/conn_spec.rb
+- spec/heroku/model/model_helper_spec.rb
+- spec/heroku/properties/null_logger_spec.rb
+- spec/heroku/properties_spec.rb
+- spec/spec_helper.rb