capgun 0.0.1 → 0.0.3

data/examples/hubot/capgun.coffee

@@ -0,0 +1,68 @@
+# Description
+#   Grab web screens/thumbs of URLs using the capgun.io service
+#
+#   Requires a CapGun API token to be set in the env var HUBOT_CAPGUN_TOKEN
+#
+# Dependencies:
+#   none
+#
+# Configuration:
+#   HUBOT_CAPGUN_TOKEN
+#
+# Commands:
+#   hubot cap <url> - Get a web screen of the url
+#
+# Notes:
+#   none
+#
+# Author:
+#   monde
+
+module.exports = (robot) ->
+  robot.respond /cap (.*)/i, (msg) ->
+    Capgun.start msg, msg.match[1]
+
+Capgun =
+
+  interval: 2500
+
+  token: process.env.HUBOT_CAPGUN_TOKEN
+
+  start: (msg, url) ->
+    this.submitOrder(msg, url)
+
+  submitOrder: (msg, url) ->
+    capgun = this
+    data = JSON.stringify({"url": url})
+    msg.http('https://api.capgun.io/v1/orders.json')
+      .headers
+        'Authorization': capgun.token,
+        'Accept': 'application/json'
+      .post(data) (err, res, body) ->
+        result = JSON.parse(body)
+        if err || res.statusCode != 200
+          message = result.message || "???"
+          msg.send "Capgun job failed with message '" + message + "', I'm bailing out!"
+        else
+          setTimeout (-> capgun.checkJob(msg, url, result.order.id, 0)), capgun.interval
+
+  checkJob: (msg, url, order_id, duration) ->
+    capgun = this
+
+    if duration > 90000
+      msg.send "Capgun job hung past 90 seconds for URL " + url + " , I'm bailing out!"
+    else
+      msg.http('https://api.capgun.io/v1/orders/' + order_id + '.json')
+        .headers
+          'Authorization': capgun.token,
+          'Accept': 'application/json'
+        .get() (err, res, body) ->
+          result = JSON.parse(body)
+          state = result.order.job.state
+
+          if state.search(/failed/) >= 0
+            msg.send "Capgun order " + order_id + " failed for URL " + url
+          else if state.search(/completed/) >= 0
+            msg.send result.order.asset_urls['640x480']
+          else
+            setTimeout (-> capgun.checkJob(msg, url, result.order.id, duration + capgun.interval)), capgun.interval

data/lib/capgun.rb

@@ -1,3 +1,31 @@
 module Capgun
-  require 'capgun/version'
+
+  require 'capgun/config'
+  require 'capgun/client'
+
+  extend Config
+
+  class << self
+
+    extend Config
+
+    # Alias for Capgun::Client.new
+    #
+    # @param [Hash] options options for the Capgun::Client
+    # @return [Capgun::Client]
+    def new(options={})
+      Capgun::Client.new(options)
+    end
+
+    # Delegate methods to Capgun::Client
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    # Corollary of #method_missing delegated to Capgun::Client
+    def respond_to?(method, include_private=false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+  end
 end

data/lib/capgun/account.rb

@@ -0,0 +1,13 @@
+module Capgun
+
+  # capgun account
+
+  class Account < Capgun::Base
+
+    include Capgun::Creatable
+
+    lazy_attr_reader :id, :name, :balance
+
+  end
+
+end

data/lib/capgun/base.rb

@@ -0,0 +1,48 @@
+require 'capgun/creatable'
+
+module Capgun
+  class Base
+    attr_accessor :attrs
+    alias :to_hash :attrs
+
+    # Define methods that retrieve the value from an initialized instance variable Hash, using the attribute as a key
+    #
+    # @overload self.lazy_attr_reader(attr)
+    #   @param attr [Symbol]
+    # @overload self.lazy_attr_reader(attrs)
+    #   @param attrs [Array<Symbol>]
+    def self.lazy_attr_reader(*attrs)
+      attrs.each do |attribute|
+        class_eval do
+          define_method attribute do
+            @attrs[attribute.to_s]
+          end
+        end
+      end
+    end
+
+    # Initializes a new Base object
+    #
+    # @param attrs [Hash]
+    # @return [Capgun::Base]
+    def initialize(attrs={})
+      @attrs = attrs.dup
+    end
+
+    # Initializes a new Base object
+    #
+    # @param method [String, Symbol] Message to send to the object
+    def [](method)
+      self.__send__(method.to_sym)
+    rescue NoMethodError
+      nil
+    end
+
+    # @param other [Capgun::Base]
+    # @return [Boolean]
+    def ==(other)
+      super || (other.class == self.class && other.id == self.id)
+    end
+
+  end
+end

data/lib/capgun/client.rb

@@ -0,0 +1,82 @@
+require 'json'
+require 'json/pure'
+require 'capgun/base'
+require 'capgun/account'
+require 'capgun/estimate'
+require 'capgun/job'
+require 'capgun/order'
+require 'capgun/config'
+require 'capgun/connection'
+require 'capgun/request'
+
+module Capgun
+
+  # Wrapper for the Capgun REST API
+  class Client
+
+    include Capgun::Connection
+    include Capgun::Request
+
+    attr_accessor *Config::VALID_OPTIONS_KEYS
+
+    # Initializes a new API object.  Accessor attributes are set based
+    # on Capgun::Config::VALID_OPTIONS_KEYS
+    #
+    # @param [Hash] attrs Addition client attributes.
+    # @return [Capgun::Client]
+    def initialize(attrs={})
+      attrs = Capgun.options.merge(attrs)
+      Config::VALID_OPTIONS_KEYS.each do |key|
+        instance_variable_set("@#{key}".to_sym, attrs[key])
+      end
+    end
+
+    # Estimates a capgun job cost / availability.
+    #
+    # @param [String] url A url that will be captured.
+    # @param [Hash] options Additional options to the capture request.
+    # @return [Capgun::Estimate] The estimate for the capture request.
+    def estimate(url, options = {})
+      estimate = post("/v1/orders/estimate.json", options.merge(:url => url))
+      Capgun::Estimate.new(estimate['order'])
+    end
+
+    # Creates a capgun job
+    #
+    # @param [String] url A url that will be captured.
+    # @param [Hash] options Additional options to the capture request.
+    # @return [Capgun::Order] The capture request order.
+    def capture(url, options = {})
+      order = post("/v1/orders.json", options.merge(:url => url))
+      Capgun::Order.new(order['order'])
+    end
+
+    # Query the order
+    #
+    # @param [String] order_id The id of a previously submitted order.
+    # @return [Capgun::Order] The capture order.
+    def order(order_id)
+      order = get("/v1/orders/#{order_id}.json")
+      Capgun::Order.new(order['order'])
+    end
+
+    # Query the status of a capture job.
+    #
+    # @param [String] job_id The id of a previously submitted capture job.
+    # @return [Capgun::Job] The capture request is a job that encapsulates status.
+    def status(job_id)
+      job = get("/v1/jobs/#{job_id}.json")
+      Capgun::Job.new(job['job'])
+    end
+
+    # Fetch account information
+    #
+    # @return [Capgun::Account] The account
+    def account
+      account = get("/v1/account.json")
+      Capgun::Account.new(account['account'])
+    end
+
+  end
+
+end

data/lib/capgun/config.rb

@@ -0,0 +1,73 @@
+require 'capgun/version'
+
+module Capgun
+
+  # Defines constants and methods related to configuration
+  module Config
+
+    # The HTTP connection adapter that will be used to connect if none is set
+    DEFAULT_ADAPTER = :net_http
+
+    # The Faraday connection options if none is set
+    DEFAULT_CONNECTION_OPTIONS = {}
+
+    # API endpoint
+    DEFAULT_ENDPOINT = 'https://api.capgun.io'
+
+    # The gateway server if none is set
+    DEFAULT_GATEWAY = nil
+
+    # The auth token if none is set
+    DEFAULT_AUTH_TOKEN = ""
+
+    # The value sent in the 'User-Agent' header if none is set
+    DEFAULT_USER_AGENT = "Capgun.io Ruby Gem #{Capgun::Version}"
+
+    # The proxy server if none is set
+    DEFAULT_PROXY = nil
+
+    # An array of valid keys in the options hash when configuring a {Capgun::Client}
+    VALID_OPTIONS_KEYS = [
+      :adapter,
+      :connection_options,
+      :endpoint,
+      :gateway,
+      :auth_token,
+      :user_agent,
+      :proxy,
+    ]
+
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+      self
+    end
+
+    # Create a hash of options and their values
+    def options
+      options = {}
+      VALID_OPTIONS_KEYS.each{|k| options[k] = send(k)}
+      options
+    end
+
+    # Reset all configuration options to defaults
+    def reset
+      self.adapter            = DEFAULT_ADAPTER
+      self.connection_options = DEFAULT_CONNECTION_OPTIONS
+      self.endpoint           = DEFAULT_ENDPOINT
+      self.gateway            = DEFAULT_GATEWAY
+      self.auth_token         = DEFAULT_AUTH_TOKEN
+      self.user_agent         = DEFAULT_USER_AGENT
+      self.proxy              = DEFAULT_PROXY
+      self
+    end
+
+  end
+end

data/lib/capgun/connection.rb

@@ -0,0 +1,36 @@
+require 'faraday'
+require 'capgun/core_ext/hash'
+require 'capgun/request/gateway'
+require 'capgun/response/parse_json'
+require 'capgun/response/raise_client_error'
+require 'capgun/response/raise_server_error'
+
+module Capgun
+  module Connection
+  private
+
+    # Returns a Faraday::Connection object
+    #
+    # @param options [Hash] A hash of options
+    # @return [Faraday::Connection]
+    def connection(options={})
+      default_options = {
+        :headers => {
+          :accept => 'application/json',
+          :user_agent => user_agent,
+          :authorization => auth_token,
+        },
+        :proxy => proxy,
+        :ssl => {:verify => false},
+        :url => options.fetch(:endpoint, endpoint),
+      }
+      @connection ||=Faraday.new(default_options.deep_merge(connection_options)) do |builder|
+        builder.use Capgun::Request::Gateway, gateway if gateway
+        builder.use Capgun::Response::RaiseClientError
+        builder.use Capgun::Response::ParseJson
+        builder.use Capgun::Response::RaiseServerError
+        builder.adapter(adapter)
+      end
+    end
+  end
+end

data/lib/capgun/core_ext/hash.rb

@@ -0,0 +1,19 @@
+class Hash
+
+  # Merges self with another hash, recursively
+  #
+  # @param hash [Hash] The hash to merge
+  # @return [Hash]
+  def deep_merge(hash)
+    target = self.dup
+    hash.keys.each do |key|
+      if hash[key].is_a?(Hash) && self[key].is_a?(Hash)
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+      target[key] = hash[key]
+    end
+    target
+  end
+
+end

data/lib/capgun/creatable.rb

@@ -0,0 +1,21 @@
+require 'time'
+
+module Capgun
+  module Creatable
+
+    # Time when the object was created
+    #
+    # @return [Time]
+    def created_at
+      @created_at ||= Time.parse(@attrs['created_at']) unless @attrs['created_at'].nil?
+    end
+
+    # Time when the object was updated
+    #
+    # @return [Time]
+    def updated_at
+      @updated_at ||= Time.parse(@attrs['updated_at']) unless @attrs['updated_at'].nil?
+    end
+
+  end
+end

data/lib/capgun/error.rb

@@ -0,0 +1,17 @@
+module Capgun
+  # Custom error class for rescuing from all Capgun errors
+  class Error < StandardError
+    attr_reader :http_headers
+
+    # Initializes a new Error object
+    #
+    # @param message [String]
+    # @param http_headers [Hash]
+    # @return [Capgun::Error]
+    def initialize(message, http_headers)
+      @http_headers = Hash[http_headers]
+      super(message)
+    end
+
+  end
+end

data/lib/capgun/error/bad_gateway.rb

@@ -0,0 +1,7 @@
+require 'capgun/error/server_error'
+
+module Capgun
+  # Raised when Capgun returns the HTTP status code 502
+  class Error::BadGateway < Capgun::Error::ServerError
+  end
+end

data/lib/capgun/error/bad_request.rb

@@ -0,0 +1,7 @@
+require 'capgun/error/client_error'
+
+module Capgun
+  # Raised when Capgun returns the HTTP status code 400
+  class Error::BadRequest < Capgun::Error::ClientError
+  end
+end

data/lib/capgun/error/client_error.rb

@@ -0,0 +1,7 @@
+require 'capgun/error'
+
+module Capgun
+  # Raised when Capgun returns a 4xx HTTP status code
+  class Error::ClientError < Capgun::Error
+  end
+end