singly 0.1.0

data/lib/singly/api/services.rb

@@ -0,0 +1,158 @@
+module Singly
+  class Services
+    include Singly::Endpoint
+
+    endpoint :get, "/services", required: [:access_token]
+
+    def thirtysevensignals(params={})
+      service(Singly::Services::ThirtySevenSignals, "37signals", params)
+    end
+
+    def bodymedia(params={})
+      service(Singly::Services::Bodymedia, __method__, params)
+    end
+
+    def dropbox(params={})
+      service(Singly::Services::Dropbox, __method__, params)
+    end
+
+    def dwolla(params={})
+      service(Singly::Services::Dwolla, __method__, params)
+    end
+
+    def facebook(params={})
+      service(Singly::Services::Facebook, __method__, params)
+    end
+
+    def fitbit(params={})
+      service(Singly::Services::Fitbit, __method__, params)
+    end
+
+    def flickr(params={})
+      service(Singly::Services::Flickr, __method__, params)
+    end
+
+    def foursquare(params={})
+      service(Singly::Services::Foursquare, __method__, params)
+    end
+
+    def gcal(params={})
+      service(Singly::Services::Gcal, __method__, params)
+    end
+
+    def gcontacts(params={})
+      service(Singly::Services::Gcontacts, __method__, params)
+    end
+
+    def gdocs(params={})
+      service(Singly::Services::Gdocs, __method__, params)
+    end
+
+    def github(params={})
+      service(Singly::Services::Github, __method__, params)
+    end
+
+    def gmail(params={})
+      service(Singly::Services::Gmail, __method__, params)
+    end
+
+    def google(params={})
+      service(Singly::Services::Google, __method__, params)
+    end
+
+    def gplus(params={})
+      service(Singly::Services::Gplus, __method__, params)
+    end
+
+    def imgur(params={})
+      service(Singly::Services::Imgur, __method__, params)
+    end
+
+    def instagram(params={})
+      service(Singly::Services::Instagram, __method__, params)
+    end
+
+    def klout(params={})
+      service(Singly::Services::Klout, __method__, params)
+    end
+
+    def linkedin(params={})
+      service(Singly::Services::Linkedin, __method__, params)
+    end
+
+    def meetup(params={})
+      service(Singly::Services::Meetup, __method__, params)
+    end
+
+    def paypal(params={})
+      service(Singly::Services::Paypal, __method__, params)
+    end
+
+    def picasa(params={})
+      service(Singly::Services::Picasa, __method__, params)
+    end
+
+    def rdio(params={})
+      service(Singly::Services::Rdio, __method__, params)
+    end
+
+    def reddit(params={})
+      service(Singly::Services::Reddit, __method__, params)
+    end
+
+    def runkeeper(params={})
+      service(Singly::Services::Runkeeper, __method__, params)
+    end
+
+    def shutterfly(params={})
+      service(Singly::Services::Shutterfly, __method__, params)
+    end
+
+    def soundcloud(params={})
+      service(Singly::Services::Soundcloud, __method__, params)
+    end
+
+    def stocktwits(params={})
+      service(Singly::Services::Stocktwits, __method__, params)
+    end
+
+    def tout(params={})
+      service(Singly::Services::Tout, __method__, params)
+    end
+
+    def tumblr(params={})
+      service(Singly::Services::Tumblr, __method__, params)
+    end
+
+    def twitter(params={})
+      service(Singly::Services::Twitter, __method__, params)
+    end
+
+    def withings(params={})
+      service(Singly::Services::Withings, __method__, params)
+    end
+
+    def wordpress(params={})
+      service(Singly::Services::Wordpress, __method__, params)
+    end
+
+    def yammer(params={})
+      service(Singly::Services::Yammer, __method__, params)
+    end
+
+    def youtube(params={})
+      service(Singly::Services::Youtube, __method__, params)
+    end
+
+    def zeo(params={})
+      service(Singly::Services::Zeo, __method__, params)
+    end
+
+    private
+
+    def service(endpoint_type, service, params)
+      params ||= {}
+      endpoint_type.new(creds.merge(params.merge(service: service.to_s)))
+    end
+  end
+end

data/lib/singly/api/types/type.rb

@@ -0,0 +1,12 @@
+module Singly
+  class Types
+    class Type
+      include Singly::Endpoint
+
+      endpoint :get, "/types/:type", {
+        required: [:access_token],
+        optional: [:fields, :limit, :since, :until, :near, :within, :q, :participants, :map, :dedup, :services]
+      }
+    end
+  end
+end

data/lib/singly/api/types.rb

@@ -0,0 +1,68 @@
+module Singly
+  class Types
+    include Singly::Endpoint
+
+    endpoint :get, "/types", required: [:access_token]
+
+    def photos(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def photos_feed(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def news(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def news_feed(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def videos(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def videos_feed(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def checkins(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def checkins_feed(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def statuses(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def statuses_feed(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def contacts(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def all(params={})
+      types_endpoint(__method__, params)
+    end
+
+    def all_feed(params={})
+      types_endpoint(__method__, params)
+    end
+
+    private
+
+    def types_endpoint(type_name, params)
+      params ||= {}
+      Singly::Types::Type.new(creds.merge(params.merge({
+        type: type_name.to_s
+      })))
+    end
+  end
+end

data/lib/singly/endpoint.rb

@@ -0,0 +1,112 @@
+# This module makes one significant assumption about the
+# structure of a singly endpoint: That no full path will
+# contain the ':' semicolon character. Semicolons here are 
+# used to describe the structure of an endpoint. For example,
+# when invoking the #endpoint class method:
+#
+#   endpoint :get, "/services/:service/:endpoint", required: [:access_token]
+#
+module Singly
+  module Endpoint
+    attr_reader :type
+    attr_reader :route
+    attr_reader :route_params
+    attr_reader :query_params
+
+    def initialize(params={})
+      params = params || {}
+      @route = self.class.route
+      @type = self.class.type
+      route_param_keys = self.class.required_route_params
+      @query_params = params.reject{|key| route_param_keys.include? key }
+      @route_params = params.select{|key| route_param_keys.include? key }
+    end
+
+    def fetch
+      validate
+      Singly::Http.fetch(type, path, query_params)
+    end
+
+    # Raises an error if any required parameters have not been
+    # supplied or if any path components are missing.
+    def validate
+      missing_route_params = self.class.required_route_params - route_params.keys
+      Singly::Error.y_u_no?("has route params :#{missing_route_params.join(', :')}") { missing_route_params.any? }
+      missing_query_params = self.class.required_params - query_params.keys
+      Singly::Error.y_u_no?("has query params :#{missing_query_params.join(', :')}") { missing_query_params.any? }
+      true  
+    end
+
+    # Constructs the path by replacing path components
+    # defined in the route with their corresponding 
+    # values in the @parameters attribute.
+    # "/profiles/:id@:service" -> "/profiles/12345@twitter"
+    def path
+      route_params.inject(route) do |route, param|
+        route.sub(":#{param[0]}", CGI.escape("#{param[1]}"))
+      end
+    end
+
+    # String representation of the composed endpoint.
+    # Parameter order is deterministic so it can be
+    # used as a key in the /multi endpoint.
+    def url
+      validate
+      query_string = query_params.sort.inject([]) do |queries, param|
+        queries << ("#{CGI.escape(param[0].to_s)}=#{CGI.escape(param[1].to_s)}")
+      end.join("&")
+      url = "#{Singly::Http.base_url}#{path}"
+      url += "?#{query_string}" unless query_string.empty?
+      return url
+    end
+
+    private
+
+    # Use this to pass credentials down the pipe
+    # eg: 
+    #   def photos(params={})
+    #     Singly::Services::Facebook.new(creds.merge(params))
+    #   end
+    def creds
+      creds = {}
+      creds[:access_token] = query_params[:access_token] if query_params[:access_token]
+      creds[:client_id] = query_params[:client_id] if query_params[:client_id]
+      creds[:client_secret] = query_params[:client_secret] if query_params[:client_secret]
+      creds
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def type
+        @type || :get
+      end
+
+      def route
+        @route || ""
+      end
+
+      def required_route_params
+        route.scan(/:(\w+)/).flatten.map(&:to_sym)
+      end
+
+      def required_params
+        (@params && @params[:required]) || []
+      end
+
+      def optional_params
+        (@params && @params[:optional]) || []
+      end
+
+      private
+
+      def endpoint(type, route, params={})
+        @type = type
+        @route = route
+        @params = params
+      end
+    end
+  end
+end

data/lib/singly/error.rb

@@ -0,0 +1,24 @@
+module Singly
+  class Error < StandardError
+    class << self
+      # Racist closure for raising errors
+      # Usage:
+      #  unhappy = true
+      #  Singly.y_u_no?("happy") { unhappy }
+      # => Singly::Error: y u no happy???
+      def y_u_no?(msg)
+        raise Error.new("y u no #{msg}???") if yield
+      end
+    end
+  end
+  class ApiError < Error
+    def initialize(response)
+      super("#{response.code} #{response.body} #{response.effective_url}")
+    end
+  end
+  class TimeoutError < Error
+    def initialize(response)
+      super("Response timed out after #{response.time} seconds. #{response.effective_url}")
+    end
+  end
+end

data/lib/singly/http.rb

@@ -0,0 +1,38 @@
+module Singly
+  class Http
+    class << self
+      include Singly::Logger
+
+      def base_url
+        "https://api.singly.com/#{Singly.version}"
+      end
+
+      def fetch(type, path, params={})
+        path = "#{base_url}#{path}"
+        log("#{type.upcase} #{path}")
+        log("PARAMS #{params}")
+        response = Typhoeus::Request.send(type, path, params: params, timeout: Singly.timeout)
+        validate_response(response)
+        parse_response(response)
+      end
+
+      private
+
+      # Singly does not yet guarantee that all responses conform to 
+      # valid json. Sometimes we can get a TypeError
+      def parse_response(response)
+        body = response.body
+        log(body)
+        JSON.parse(body) rescue body
+      end
+
+      # Does two things:
+      # 1) Handles timeout errors
+      # 2) Handles generic non-200 code errors
+      def validate_response(response)
+        raise Singly::TimeoutError.new(response) if response.timed_out?
+        raise Singly::ApiError.new(response) if response.code != 200
+      end
+    end
+  end
+end

data/lib/singly/logger.rb

@@ -0,0 +1,14 @@
+module Singly
+  module Logger
+    def log(msg)
+      return unless Singly.verbose
+      if defined?(Rails)
+        Rails.logger.info("[singly] #{msg}")  # Naive logging.
+                                              # This lumberjack will log in Rails if defined.
+                                              # Otherwise it just puts all logs to stdout
+      else
+        puts "[singly] #{msg}"
+      end
+    end
+  end
+end

data/lib/singly.rb

@@ -0,0 +1,37 @@
+($LOAD_PATH << File.dirname(__FILE__)) unless $LOAD_PATH.include? File.dirname(__FILE__)
+
+require "cgi"
+require "rubygems"
+require "typhoeus"
+require "json"
+require "singly/logger"
+require "singly/endpoint"
+require "singly/api/services/service"
+
+# Descend into and require the entire project
+Dir["#{File.dirname(__FILE__)}/**/*.rb"].each {|f| require(f)}
+
+module Singly
+  @version = "v0"
+  @timeout = 2000
+
+  class << self
+    attr_accessor :client_id
+    attr_accessor :client_secret
+    attr_accessor :verbose
+    attr_accessor :version
+    attr_accessor :timeout
+
+    def account(access_token, account=nil)
+      Singly::Account.new(access_token, account)
+    end
+
+    def auth
+      Singly::Auth.new
+    end
+
+    def multi(urls)
+      Singly::Multi.new(urls: urls.join(","))
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Singly
+  VERSION = "0.1.0"
+end

data/singly.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "singly"
+  gem.version       = Singly::VERSION
+  gem.authors       = ["Kevin Cantwell"]
+  gem.email         = ["kevin@timehop.com"]
+  gem.description   = %q{Object-oriented interaction with the Singly API}
+  gem.summary       = %q{See documentation at TBD}
+  gem.homepage      = ""
+
+  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"]
+
+  # Gemfile woulda-beens
+  gem.add_dependency("json", ["~> 1.7.6"])
+  gem.add_dependency("typhoeus", [">= 0.5.4", "< 0.7"])
+  gem.add_development_dependency("rspec", ["~> 2.8"])
+  gem.add_development_dependency("vcr", ["~> 2.3"])
+end

data/spec/integration/auth_spec.rb

@@ -0,0 +1,14 @@
+require 'singly'
+require 'yaml'
+
+describe "Auth Integration" do
+  if ENV["CONFIG"]
+    config = YAML::load_file( ENV["CONFIG"] )
+    Singly.client_id = config[:singly][:client_id]
+    Singly.client_secret = config[:singly][:client_secret]
+
+    params = {token: config[:facebook][:token]}
+    r = Singly.auth.facebook.apply(params).fetch
+    puts r
+  end
+end

data/spec/singly/account_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Singly::Account do
+  describe "#initialize" do
+    context "with access_token" do  
+      subject { Singly::Account.new("access_tolkien").access_token }
+      it { should == "access_tolkien" }
+    end
+    context "with account_id" do
+      subject { Singly::Account.new("access_tolkien", "a_count_eye_dee").account_id }
+      it { should == "a_count_eye_dee" }
+    end
+  end
+  let(:account) { Singly::Account.new(access_token, account_id) }
+  let(:access_token) { "fake_access_token" }
+  let(:account_id) { nil }
+  describe "#account_id" do
+    context "when an account_id is specified" do
+      let(:account_id) { "fake_account_id" }
+      subject { account.account_id }
+      it { should == "fake_account_id" }
+    end
+    context "when no account_id is specified" do
+      subject { account.account_id }
+      before { account.stub_chain(:profiles, :fetch).and_return("id" => "this_tests_account_id") }
+      it { should == "this_tests_account_id" }
+    end
+  end
+  describe "#profile" do
+    subject { account.profile }
+    it { subject.class.should == Singly::Profile }
+    it { subject.validate.should be_true }
+  end
+  describe "#profiles" do
+    context "without params" do
+      subject { account.profiles }
+      it { subject.class.should == Singly::Profiles }
+      it { subject.validate.should be_true }
+    end
+    context "with optional params" do
+      subject { account.profiles(data: true, verify: true) }
+      it { subject.class.should == Singly::Profiles }
+      it { subject.validate.should be_true }
+      it { subject.query_params.should include(data: true, verify: true) }
+    end
+  end
+  describe "#types" do
+    subject { account.types }
+    it { subject.class.should == Singly::Types }
+    it { subject.validate.should be_true }
+  end
+  describe "#services" do
+    subject { account.services }
+    it { subject.class.should == Singly::Services }
+    it { subject.validate.should be_true }
+  end
+  describe "#id" do
+    context "without params" do
+      subject { account.id("abc123") }
+      it { subject.class.should == Singly::Id }
+      it { subject.validate.should be_true }
+    end
+    context "with optional params" do
+      subject { account.id("abc123", map: true) }
+      it { subject.class.should == Singly::Id }
+      it { subject.validate.should be_true }
+      it { subject.query_params.should include(map: true) }
+    end
+  end
+  describe "#delete" do
+    context "where we delete all profiles by service" do
+      subject { account.delete(:facebook) }
+      it { subject.class.should == Singly::Profiles::DeleteService }
+      it { subject.validate.should be_true }
+      it { subject.route_params.should include(service: "facebook") }
+    end
+    context "where we delete a specific profile by id" do
+      subject { account.delete(:facebook, 987654321) }
+      it { subject.class.should == Singly::Profiles::DeleteProfile }
+      it { subject.validate.should be_true }
+      it { subject.route_params.should include(service: "facebook", id: "987654321") }
+    end
+  end
+  describe "#merge" do
+    subject { account.merge("fake_source_access_token") }
+    it { subject.class.should == Singly::Auth::Merge }
+    it { subject.validate.should be_true }
+    it { subject.query_params.should include(
+      source: "fake_source_access_token",
+      dest: "fake_access_token"
+    ) }
+  end
+  describe "#apply" do
+    let(:account_id) { "fake_account_id" }
+    context "with an oauth2 service" do
+      subject { account.apply(:instagram, token: "tokin") }
+      it { subject.class.should == Singly::Auth::Service::Oauth2Apply }
+      it { subject.validate.should be_true }
+      it { subject.query_params.should include(account: "fake_account_id") }
+    end
+    context "with an oauth1 service" do
+      subject { account.apply(:flickr, token: "tokin", token_secret: "shhh_tokin") }
+      it { subject.class.should == Singly::Auth::Service::Oauth1Apply }
+      it { subject.validate.should be_true }
+      it { subject.query_params.should include(account: "fake_account_id") }
+    end
+  end
+end

data/spec/singly/api/auth_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Singly::Auth do
+  describe "#merge" do
+    subject { Singly::Auth.new.merge(source: "abc", dest: "123").url }
+    it { should == "https://api.singly.com/v0/auth/merge?dest=123&source=abc" }
+  end
+end