GooglePlus 0.0.2

data/lib/google_plus/configuration.rb

@@ -0,0 +1,21 @@
+require 'active_support/core_ext/enumerable'
+require 'google_plus/base'
+require 'google_plus/size'
+
+module GooglePlus
+  class Configuration < GooglePlus::Base
+    lazy_attr_reader :characters_reserved_per_media, :max_media_per_upload,
+      :non_username_paths, :photo_size_limit, :short_url_length, :short_url_length_https
+
+    # Returns an array of photo sizes
+    #
+    # @return [Array<GooglePlus::Size>]
+    def photo_sizes
+      @photo_sizes ||= Array(@attrs['photo_sizes']).each_with_object({}) do |(key, value), object|
+        object[key] = GooglePlus::Size.new(value)
+      end
+    end
+
+  end
+end
+

data/lib/google_plus/connection.rb

@@ -0,0 +1,44 @@
+require 'faraday'
+require 'google_plus/request/gateway'
+require 'google_plus/request/multipart_with_file'
+require 'google_plus/request/phoenix'
+require 'google_plus/request/oauth'
+require 'google_plus/response/parse_json'
+require 'google_plus/response/raise_client_error'
+require 'google_plus/response/raise_server_error'
+
+module GooglePlus
+  module Connection
+  private
+
+    # Returns a Faraday::Connection object
+    #
+    # @return [Faraday::Connection]
+    def connection(options={})
+      merged_options = connection_options.merge({
+        :headers => {
+          :accept => 'application/json',
+          :user_agent => user_agent,
+        },
+        :proxy => proxy,
+        :ssl => {:verify => false},
+        :url => options.fetch(:endpoint, api_endpoint),
+      })
+    
+     Faraday.new(merged_options) do |builder|
+        builder.use GooglePlus::Request::Phoenix if options[:phoenix]
+        builder.use GooglePlus::Request::MultipartWithFile
+        builder.use GooglePlus::Request::GooglePlusOAuth, credentials if credentials?
+        builder.use Faraday::Request::Multipart
+        builder.use Faraday::Request::UrlEncoded
+        builder.use GooglePlus::Request::Gateway, gateway if gateway
+        builder.use GooglePlus::Response::RaiseClientError
+        builder.use GooglePlus::Response::ParseJson unless options[:raw]
+        builder.use GooglePlus::Response::RaiseServerError
+        builder.adapter(adapter)
+     end
+    end
+
+  end
+end
+

data/lib/google_plus/core_ext/hash.rb

@@ -0,0 +1,66 @@
+class Hash
+
+  # Take a single user ID or screen name and merge it into the hash with the correct key
+  #
+  # @param user_id_or_screen_name [Integer, String] A Twitter user ID or screen_name.
+  # @return [Hash]
+  def merge_user!(user_id_or_screen_name)
+    case user_id_or_screen_name
+    when Integer
+      self[:user_id] = user_id_or_screen_name
+    when String
+      self[:screen_name] = user_id_or_screen_name
+    end
+    self
+  end
+
+  # Take a multiple user IDs and screen names and merge them into the hash with the correct keys
+  #
+  # @param users_id_or_screen_names [Array] An array of Twitter user IDs or screen_names.
+  # @return [Hash]
+  def merge_users!(user_ids_or_screen_names)
+    user_ids, screen_names = [], []
+    user_ids_or_screen_names.flatten.each do |user_id_or_screen_name|
+      case user_id_or_screen_name
+      when Integer
+        user_ids << user_id_or_screen_name
+      when String
+        screen_names << user_id_or_screen_name
+      end
+    end
+    self[:user_id] = user_ids.join(',') unless user_ids.empty?
+    self[:screen_name] = screen_names.join(',') unless screen_names.empty?
+    self
+  end
+
+  # Take a single owner ID or owner screen name and merge it into the hash with the correct key
+  # (for Twitter API endpoints that want :owner_id and :owner_screen_name)
+  #
+  # @param owner_id_or_owner_screen_name [Integer, String] A Twitter user ID or screen_name.
+  # @return [Hash]
+  def merge_owner!(owner_id_or_owner_screen_name)
+    case owner_id_or_owner_screen_name
+    when Integer
+      self[:owner_id] = owner_id_or_owner_screen_name
+    when String
+      self[:owner_screen_name] = owner_id_or_owner_screen_name
+    end
+    self
+  end
+
+  # Take a single list ID or slug and merge it into the hash with the correct key
+  #
+  # @param list_id_or_slug [Integer, String] A Twitter list ID or slug.
+  # @return [Hash]
+  def merge_list!(list_id_or_screen_name)
+    case list_id_or_screen_name
+    when Integer
+      self[:list_id] = list_id_or_screen_name
+    when String
+      self[:slug] = list_id_or_screen_name
+    end
+    self
+  end
+
+end
+

data/lib/google_plus/creatable.rb

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

data/lib/google_plus/cursor.rb

@@ -0,0 +1,45 @@
+require 'active_support/core_ext/kernel/singleton_class'
+require 'google_plus/base'
+
+module GooglePlus
+  class Cursor < GooglePlus::Base
+    attr_reader :collection
+    lazy_attr_reader :next_cursor, :previous_cursor
+    alias :next :next_cursor
+    alias :previous :previous_cursor
+
+    # Initializes a new Cursor object
+    #
+    # @param attrs [Hash]
+    # @params method [String, Symbol] The name of the method to return the collection
+    # @params klass [Class] The class to instantiate object in the collection
+    # @return [GooglePlus::Cursor]
+    def initialize(attrs, method, klass=nil)
+      super(attrs)
+      @collection = Array(attrs[method.to_s]).map do |item|
+        if klass
+          klass.new(item)
+        else
+          item
+        end
+      end
+      singleton_class.class_eval do
+        alias_method method.to_sym, :collection
+      end
+    end
+
+    # @return [Boolean]
+    def first?
+      previous_cursor.zero?
+    end
+    alias :first :first?
+
+    # @return [Boolean]
+    def last?
+      next_cursor.zero?
+    end
+    alias :last :last?
+
+  end
+end
+

data/lib/google_plus/direct_message.rb

@@ -0,0 +1,28 @@
+require 'google_plus/base'
+#require 'google_plus/creatable'
+#require 'google_plus/user'
+
+module GooglePlus
+  class DirectMessage < GooglePlus::Base
+    include GooglePlus::Creatable
+    lazy_attr_reader :id, :text
+
+    # @param other [Twiter::DirectMessage]
+    # @return [Boolean]
+    def ==(other)
+      super || (other.class == self.class && other.id == self.id)
+    end
+
+    # @return [GooglePlus::User]
+    def recipient
+      @recipient ||= GooglePlus::User.new(@attrs['recipient']) unless @attrs['recipient'].nil?
+    end
+
+    # @return [GooglePlus::User]
+    def sender
+      @sender ||= GooglePlus::User.new(@attrs['sender']) unless @attrs['sender'].nil?
+    end
+
+  end
+end
+

data/lib/google_plus/error.rb

@@ -0,0 +1,38 @@
+module GooglePlus
+  # Custom error class for rescuing from all GooglePlus errors
+  class Error < StandardError
+    attr_reader :http_headers
+
+    # Initializes a new Error object
+    #
+    # @param message [String]
+    # @param http_headers [Hash]
+    # @return [Twitter::Error]
+    def initialize(message, http_headers)
+      @http_headers = Hash[http_headers]
+      super(message)
+    end
+
+    # @return [Time]
+    def ratelimit_reset
+      Time.at(@http_headers.values_at('x-ratelimit-reset', 'X-RateLimit-Reset').detect{|value| value}.to_i)
+    end
+
+    # @return [Integer]
+    def ratelimit_limit
+      @http_headers.values_at('x-ratelimit-limit', 'X-RateLimit-Limit').detect{|value| value}.to_i
+    end
+
+    # @return [Integer]
+    def ratelimit_remaining
+      @http_headers.values_at('x-ratelimit-remaining', 'X-RateLimit-Remaining').detect{|value| value}.to_i
+    end
+
+    # @return [Integer]
+    def retry_after
+      [(ratelimit_reset - Time.now).ceil, 0].max
+    end
+
+  end
+end
+

data/lib/google_plus/error/client_error.rb

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

data/lib/google_plus/error/forbidden.rb

@@ -0,0 +1,8 @@
+require 'google_plus/error/client_error'
+
+module GooglePlus
+  # Raised when Twitter returns the HTTP status code 403
+  class Error::Forbidden < GooglePlus::Error::ClientError
+  end
+end
+

data/lib/google_plus/error/unauthorized.rb

@@ -0,0 +1,8 @@
+require 'google_plus/error/client_error'
+
+module GooglePlus
+  # Raised when GooglePlus returns the HTTP status code 401
+  class Error::Unauthorized < GooglePlus::Error::ClientError
+  end
+end
+

data/lib/google_plus/geo_factory.rb

@@ -0,0 +1,23 @@
+require 'google_plus/point'
+require 'google_plus/polygon'
+
+module GooglePlus
+  class GeoFactory
+
+    # Instantiates a new geo object
+    #
+    # @param attrs [Hash]
+    # @raise [ArgumentError] Error raised when supplied argument is missing a type key.
+    # @return [GooglePlus::Point, GooglePlus::Polygon]
+    def self.new(geo={})
+      type = geo['type']
+      if type
+        GooglePlus.const_get(type.capitalize.to_sym).new(geo)
+      else
+        raise ArgumentError, "argument must have a type key"
+      end
+    end
+
+  end
+end
+

data/lib/google_plus/metadata.rb

@@ -0,0 +1,8 @@
+require 'google_plus/base'
+
+module GooglePlus
+  class Metadata < GooglePlus::Base
+    lazy_attr_reader :result_type
+  end
+end
+

data/lib/google_plus/request.rb

@@ -0,0 +1,37 @@
+module GooglePlus
+  # Defines HTTP request methods
+  module Request
+    # Perform an HTTP DELETE request
+    def delete(path, params={}, options={})
+      request(:delete, path, params, options)
+    end
+
+    # Perform an HTTP GET request
+    def get(path, params={}, options={})
+      request(:get, path, params, options)
+    end
+
+    # Perform an HTTP POST request
+    def post(path, params={}, options={})
+      request(:post, path, params, options)
+    end
+
+  private
+
+    # Perform an HTTP request
+    def request(method, path, params, options)
+      response = connection(options).send(method) do |request|
+        case method.to_sym
+        when :delete, :get
+          request.url(path, params)
+        when :post
+          request.path = path
+          request.body = params unless params.empty?
+        end
+      end
+      options[:raw] ? response : response.body
+    end
+
+  end
+end
+

data/lib/google_plus/request/gateway.rb

@@ -0,0 +1,21 @@
+require 'faraday'
+
+module GooglePlus
+  module Request
+    class Gateway < Faraday::Middleware
+
+      def call(env)
+        url = env[:url].dup
+        url.host = @gateway
+        env[:url] = url
+        @app.call(env)
+      end
+
+      def initialize(app, gateway)
+        @app, @gateway = app, gateway
+      end
+
+    end
+  end
+end
+

data/lib/google_plus/request/multipart_with_file.rb

@@ -0,0 +1,38 @@
+require 'faraday'
+
+module GooglePlus
+  module Request
+    class MultipartWithFile < Faraday::Middleware
+
+      def call(env)
+        if env[:body].is_a?(Hash)
+          env[:body].each do |key, value|
+            if value.is_a?(File)
+              env[:body][key] = Faraday::UploadIO.new(value, mime_type(value.path), value.path)
+            elsif value.is_a?(Hash) && (value['io'].is_a?(IO) || value['io'].is_a?(StringIO))
+              env[:body][key] = Faraday::UploadIO.new(value['io'], mime_type('.'+value['type']), '')
+            end
+          end
+        end
+        @app.call(env)
+      end
+
+    private
+
+      def mime_type(path)
+        case path
+        when /\.jpe?g/i
+          'image/jpeg'
+        when /\.gif$/i
+          'image/gif'
+        when /\.png$/i
+          'image/png'
+        else
+          'application/octet-stream'
+        end
+      end
+
+    end
+  end
+end
+