anideo-embedly 1.3.0

data/features/steps/api_steps.rb

@@ -0,0 +1,56 @@
+$:.unshift(File.expand_path('../../../lib',__FILE__))
+require 'embedly'
+
+# cache for hostnames
+HOSTNAMES = {}
+
+Given /an embedly api( with key)?$/ do |key_enabled|
+  opts = {}
+  if key_enabled
+    raise 'Please set env variable $EMBEDLY_KEY' unless ENV['EMBEDLY_KEY']
+    opts[:key] = ENV["EMBEDLY_KEY"]
+    opts[:secret] = ENV["EMBEDLY_SECRET"]
+  end
+  if not HOSTNAMES[opts]
+    HOSTNAMES[opts] = Embedly::API.new opts
+  end
+  @api = HOSTNAMES[opts]
+end
+
+When /(\w+) is called with the (.*) URLs?( and ([^\s]+) flag)?$/ do |method, urls, _, flag|
+  @result = nil
+  begin
+    urls = urls.split(',')
+    opts = {}
+    if urls.size == 1
+      opts[:url] = urls.first
+    else
+      opts[:urls] = urls
+    end
+    opts[flag.to_sym] = true if flag
+    @result = @api.send(method, opts)
+  rescue
+    @error = $!
+  end
+end
+
+Then /an? (\w+) error should get thrown/ do |error|
+  @error.class.to_s.should == error
+end
+
+Then /objectify api_version is (\d+)$/ do |version|
+  @api.api_version[:objectify].should == version
+end
+
+Then /([^\s]+) should be (.+)$/ do |key, value|
+  raise @error if @error
+  @result.collect do |o|
+    o.send(key).to_s
+  end.join(',').should == value
+end
+
+Then /([^\s]+) should start with ([^\s]+)/ do |key, value|
+  raise @error if @error
+  v = key.split('.').inject(@result[0]){|o,c| o.send(c)}.to_s
+  v.to_s.should match(/^#{value}/)
+end

data/features/steps/env.rb

@@ -0,0 +1,10 @@
+require 'aruba/cucumber'
+require 'embedly'
+
+Before do
+  @aruba_timeout_seconds = 15
+end
+
+Embedly.configure do |config|
+  config.debug = !!ENV["EMBEDLY_VERBOSE"]
+end

data/lib/embedly.rb

@@ -0,0 +1,15 @@
+module Embedly
+  VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip
+
+  class << self
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+end
+
+require 'embedly/api'

data/lib/embedly/api.rb

@@ -0,0 +1,234 @@
+require 'net/http'
+require 'net/https'
+require 'json'
+require 'ostruct'
+require 'embedly/configuration'
+require 'embedly/model'
+require 'embedly/exceptions'
+require 'querystring'
+require 'oauth'
+require 'typhoeus'
+
+# Performs api calls to embedly.
+#
+# You won't find methods.  We are using method_missing and passing the method
+# name to apicall.
+#
+# === Currently Supported Methods
+#
+# * +oembed+
+# * +objectify+
+# * +preview+
+#
+# All methods return ostructs, so fields can be accessed with the dot operator. ex.
+#
+#   api = Embedly::API.new
+#   obj = api.oembed :url => 'http://blog.doki-pen.org/'
+#   puts obj[0].title, obj[0].description, obj[0].thumbnail_url
+#
+# Call parameters should be passed as the opts parameter.  If set, key will
+# automatically be added to the query string of the call, so no need to set it.
+#
+# This API _would_ be future compatible, if not for the version.  In order to
+# add support for a new method, you will need to add a version to the
+# api_version hash.  Here is an example.
+#
+#   api = Embedly::API.new
+#   api.api_version[:new_method] = 3
+#   api.new_method :arg1 => '1', :arg2 => '2'
+#
+class Embedly::API
+  attr_reader :key, :hostname, :api_version, :headers, :secret
+
+  # === Options
+  #
+  # [:+hostname+] Hostname of embedly server.  Defaults to api.embed.ly.
+  # [:+key+] Your api.embed.ly key.
+  # [:+secret+] Your api.embed.ly secret if you are using oauth.
+  # [:+user_agent+] Your User-Agent header.  Defaults to Mozilla/5.0 (compatible; embedly-ruby/VERSION;)
+  # [:+timeout+] Request timeout (in seconds).  Defaults to 180 seconds or 3 minutes
+  # [:+headers+] Additional headers to send with requests.
+  def initialize opts={}
+    @endpoints = [:oembed, :objectify, :preview]
+    @key = opts[:key]
+    @secret = opts[:secret] == "" ? nil : opts[:secret]
+    @api_version = Hash.new('1')
+    @api_version.merge!({:objectify => '2'})
+    @hostname = opts[:hostname] || 'api.embed.ly'
+    @timeout = opts[:timeout] || 180
+    @headers = {
+      'User-Agent' => opts[:user_agent] || "Mozilla/5.0 (compatible; embedly-ruby/#{Embedly::VERSION};)"
+    }.merge(opts[:headers]||{})
+  end
+
+  def _do_typhoeus_call path
+    scheme, host, port = uri_parse hostname
+    url = "#{scheme}://#{hostname}:#{port}#{path}"
+    logger.debug { "calling #{site}#{path} with headers #{headers} using Typhoeus" }
+    Typhoeus::Request.get(url, {:headers => headers, :timeout => (@timeout*1000) })
+  end
+
+  def _do_basic_call path
+    scheme, host, port = uri_parse hostname
+    logger.debug { "calling #{site}#{path} with headers #{headers} using Net::HTTP" }
+    Net::HTTP.start(host, port, :use_ssl => scheme == 'https') do |http|
+      http.read_timeout = @timeout
+      http.get(path, headers)
+    end
+  end
+
+  def _do_oauth_call path
+    consumer = OAuth::Consumer.new(key, secret,
+      :site => site,
+      :http_method => :get,
+      :scheme => :query_string)
+    # our implementation is broken for header authorization, thus the
+    # query_string
+
+    access_token = OAuth::AccessToken.new consumer
+    logger.debug { "calling #{site}#{path} with headers #{headers} via OAuth" }
+    access_token.get path, headers
+  end
+
+  def _do_call path
+    if key and secret
+      _do_oauth_call path
+    else
+      configuration.typhoeus ? _do_typhoeus_call(path) : _do_basic_call(path)
+    end
+  end
+
+  # <b>Use methods oembed, objectify, preview in favor of this method.</b>
+  #
+  # Normalizes url and urls parameters and calls the endpoint.  url OR urls
+  # must be present
+  #
+  # === Options
+  #
+  # [:+url+] _(optional)_ A single url
+  # [:+urls+] _(optional)_ An array of urls
+  # [:+action+] The method that should be called. ex. oembed, objectify, preview
+  # [:+version+] The api version number.
+  # [_others_] All other parameters are used as query strings.
+  def apicall opts
+    opts[:urls] ||= []
+    opts[:urls] << opts[:url] if opts[:url]
+
+    raise 'must pass urls' if opts[:urls].size == 0
+
+    params = {:urls => opts[:urls]}
+
+    # store unsupported services as errors and don't send them to embedly
+    rejects = []
+    if not key
+      params[:urls].reject!.with_index do |url, i|
+        if url !~ services_regex
+          rejects << [i,
+            Embedly::EmbedlyObject.new(
+              :type => 'error',
+              :error_code => 401,
+              :error_message => 'Embedly api key is required.'
+            )
+          ]
+        end
+      end
+    end
+
+    if params[:urls].size > 0
+      params[:key] = key if key and not secret
+      params.merge!Hash[
+        opts.select{|k,_| not [:url, :urls, :action, :version].index k}
+      ]
+
+      path = "/#{opts[:version]}/#{opts[:action]}?#{QueryString.stringify(params)}"
+
+      response = _do_call path
+
+      if response.code.to_i == 200
+        logger.debug { response.body }
+        # [].flatten is to be sure we have an array
+        objs = [JSON.parse(response.body)].flatten.collect do |o|
+          Embedly::EmbedlyObject.new(o)
+        end
+      else
+        logger.debug { response }
+        raise Embedly::BadResponseException.new(response, path)
+      end
+
+      # re-insert rejects into response
+      rejects.each do |i, obj|
+        objs.insert i, obj
+      end
+
+      objs
+    else
+      # we only have rejects, return them without calling embedly
+      rejects.collect{|i, obj| obj}
+    end
+  end
+
+  # Returns structured data from the services API method.
+  #
+  # Response is cached per API object.
+  #
+  # see http://api.embed.ly/docs/service for a description of the response.
+  def services
+    if not @services
+      response = _do_call '/1/services/ruby'
+      raise 'services call failed', response if response.code.to_i != 200
+      @services = JSON.parse(response.body)
+    end
+    @services
+  end
+
+  # Returns a regex suitable for checking urls against for non-key usage
+  def services_regex
+    r = services.collect {|p| p["regex"].join("|")}.join("|")
+    Regexp.new r
+  end
+
+  # Performs api call based on method name
+  #
+  # === Currently supported
+  #
+  # - +oembed+
+  # - +objectify+
+  # - +preview+
+  #
+  def method_missing(name, *args, &block)
+    if @endpoints.include?name
+      opts = args[0]
+      opts[:action] = name
+      opts[:version] = @api_version[name]
+      apicall opts
+    else
+      super
+    end
+  end
+
+  private
+  def uri_parse uri
+    uri =~ %r{^((http(s?))://)?([^:/]+)(:([\d]+))?(/.*)?$}
+    scheme = $2 || 'http'
+    host = $4
+    port = $6 ? $6 : ( scheme == 'https' ? 443 : 80)
+    [scheme, host, port.to_i]
+  end
+
+  def site
+    scheme, host, port = uri_parse hostname
+    if (scheme == 'http' and port == 80) or (scheme == 'https' and port == 443)
+      "#{scheme}://#{host}"
+    else
+      "#{scheme}://#{host}:#{port}"
+    end
+  end
+
+  def logger
+    configuration.logger
+  end
+
+  def configuration
+    Embedly.configuration
+  end
+end

data/lib/embedly/command_line.rb

@@ -0,0 +1,132 @@
+require "optparse"
+
+module Embedly
+  class CommandLine
+
+    class Parser
+      attr_accessor :options
+
+      def initialize(args)
+        @options, @args = default, args
+      end
+
+      def parse!
+        parser.parse!(@args)
+        set_urls!
+        reject_nil!
+        options
+      rescue OptionParser::InvalidOption => error
+        puts "ERROR: #{error.message}"
+        puts parser.on_tail
+        exit
+      end
+
+      def self.parse!(args)
+        new(args).parse!
+      end
+
+      private
+
+      def default
+        {
+          :key => ENV['EMBEDLY_KEY'],
+          :secret => ENV['EMBEDLY_SECRET'],
+          :headers => {},
+          :query => {},
+          :typhoeus => true
+        }
+      end
+
+      def reject_nil!
+        options.reject! { |_, opt| opt.nil? }
+      end
+
+      def set_urls!
+        raise(OptionParser::InvalidOption, "url required") if @args.empty?
+        options[:query][:urls] = @args
+      end
+
+      def parser
+        OptionParser.new do |parser|
+          parser.banner = %{
+Fetch JSON from the embedly service.
+Usage [OPTIONS] <url> [url] ..
+}
+
+          parser.separator ""
+          parser.separator "Options:"
+
+          parser.on('-H', '--hostname ENDPOINT', 'Embedly host. Default is api.embed.ly.') do |hostname|
+            options[:hostname] = hostname
+          end
+
+          parser.on("--header NAME=VALUE", "HTTP header to send with requests.") do |hash|
+            header, value = hash.split '='
+            options[:headers][header] = value
+          end
+
+          parser.on("-k", "--key KEY", "Embedly key [default: EMBEDLY_KEY environmental variable]") do |key|
+            options[:key] = key
+          end
+
+          parser.on("-N", "--no-key", "Ignore EMBEDLY_KEY environmental variable") do |key|
+            options[:key] = nil
+          end
+
+          parser.on("-s", "--secret SECRET", "Embedly secret [default: EMBEDLY_SECRET environmental variable]") do |secret|
+            options[:secret] = secret
+          end
+
+          parser.on("--no-secret", "Ignore EMBEDLY_SECRET environmental variable") do
+            options[:secret] = nil
+          end
+
+          parser.on("-o", "--option NAME=VALUE", "Set option to be passed as query param.") do |option|
+            key, value = option.split('=')
+            options[:query][key.to_sym] = value
+          end
+
+          parser.on("--no-typhoeus", "Don't use typhoeus.") do
+            Embedly.configuration.typhoeus = false
+          end
+
+          parser.separator ""
+          parser.separator "Common Options:"
+
+          parser.on("-v", "--[no-]verbose", "Run verbosely") do |verbose|
+            Embedly.configuration.debug = verbose
+          end
+
+          parser.on("-h", "--help", "Display this message") do
+            puts parser
+            exit
+          end
+
+          parser.separator ""
+          parser.separator "Bob Corsaro <bob@embed.ly>"
+        end
+      end
+    end
+
+    class << self
+      def run!(endpoint, args = [])
+        new(args).run(endpoint)
+      end
+    end
+
+    def initialize(args)
+      @options, @args = {}, args
+    end
+
+    def run(endpoint = :oembed)
+      api_options = options.dup
+      query = api_options.delete(:query)
+      Embedly::API.new(api_options).send(endpoint, query)
+    end
+
+    def options
+      @options = Parser.parse!(@args.dup)
+      @options
+    end
+  end
+end