verticalresponse 0.1.1

data/lib/resource.rb

@@ -0,0 +1,152 @@
+# This is the base class for a VerticalResponse resource.
+# It contains common object oriented functionality that other resource classes
+# can use to interact with the API.
+
+require_relative 'client'
+
+module VerticalResponse
+  module API
+    class Resource < Client
+      class << self
+        def class_for_resource(original_class, id = nil)
+          # Create a new anonymous class to prevent conflicts with other classes
+          new_class = Class.new(original_class)
+          new_class.embed_resource(resource_name, id)
+          new_class
+        end
+
+        # Exclude methods that are not supported by the current resource API.
+        # This applies for common methods that are shared across all classes:
+        #   - Class methods: all, find, create
+        #   - Instance methods: update, delete, stats
+        def exclude_methods(*methods)
+          @excluded_methods = methods
+        end
+
+        def validate_supported_method!(method)
+          if @excluded_methods && @excluded_methods.include?(method.to_sym)
+            raise NotImplementedError,
+              "This method is not supported for the #{ class_name } class"
+          end
+        end
+
+        def class_name
+          # Use the superclass name if the current class name is not defined
+          # (e.g. for anonymous classes)
+          name || superclass.name
+        end
+
+        def resource_name
+          # Manually pluralize just by adding an 's' and underscore manually
+          # We want this wrapper to be Rails-independent
+          "#{ class_name.split('::').last.gsub(/(.)([A-Z])/,'\1_\2').downcase }s"
+        end
+
+        def id_regexp
+          /\d+/
+        end
+
+        def id_attribute_name
+          'id'
+        end
+
+        # Get the ID of a resource based on a given URL
+        def resource_id_from_url(url)
+          url.match(/#{ resource_name }\/(#{ id_regexp })/)[1]
+        end
+
+        ##################################
+        # Common object oriented methods #
+        ##################################
+
+        # Returns a collection of current class objects.
+        # Useful for when we need to have an object oriented way to
+        # handle a list of items from an API response
+        def object_collection(response)
+          response.handle_collection do |response_item|
+            self.new(response_item)
+          end
+        end
+
+        # Returns all the objects of the current class
+        def all(options = {})
+          validate_supported_method!(:all)
+
+          response = Response.new get(resource_uri, build_query_params(options))
+
+          object_collection(response)
+        end
+
+        # Find and return an object of the current class based on its ID
+        def find(id, options = {})
+          validate_supported_method!(:find)
+
+          response = Response.new get(resource_uri(id), build_query_params(options))
+
+          self.new(response)
+        end
+
+        # Creates a new object of the current class with the parameters provided
+        def create(params)
+          validate_supported_method!(:create)
+
+          response = Response.new post(
+            resource_uri,
+            build_params(params)
+          )
+          self.new(response)
+        end
+      end
+
+      # Returns the ID of the current object based on the response
+      def id
+        if @id.nil? && response
+          if response.attributes && response.attributes.has_key?(self.class::id_attribute_name)
+            @id = response.attributes[self.class::id_attribute_name]
+          elsif url
+            # This case is useful if we need the ID right after a call
+            # that does not return any atributes, like create
+            @id = self.class.resource_id_from_url(url)
+          end
+        end
+        @id
+      end
+
+      def url
+        response.url
+      end
+
+      def update(params)
+        self.class.validate_supported_method!(:update)
+
+        response = Response.new self.class.put(
+          self.class.resource_uri(id),
+          self.class.build_params(params)
+        )
+        self.class.new(response)
+      end
+
+      def delete(params = {})
+        self.class.validate_supported_method!(:delete)
+
+        Response.new self.class.delete(
+          self.class.resource_uri(id),
+          self.class.build_params(params)
+        )
+      end
+
+      # Returns the summary stats for the current object
+      def stats(options = {})
+        self.class.validate_supported_method!(:stats)
+
+        if response.links && response.links.has_key?('stats')
+          uri = response.links['stats']['url']
+        else
+          uri = self.class.resource_uri(id, 'stats')
+        end
+
+        Response.new self.class.get(uri, self.class.build_query_params(options))
+      end
+    end
+  end
+end

data/lib/response.rb

@@ -0,0 +1,48 @@
+# Class that represents the response you can get from calling any action
+# of the VerticalResponse API.
+
+require_relative 'error'
+
+module VerticalResponse
+  module API
+    class Response
+      attr_reader :url, :items, :attributes, :links, :success, :error, :raw_response
+
+      def initialize(response)
+        @url =          response['url']
+        @items =        response['items']
+        @attributes =   response['attributes']
+        @links =        response['links']
+        @success =      response['success']
+        @error =        response['error']
+        @raw_response = response
+
+        handle_error unless success?
+      end
+
+      # Iterate through the collection of items and yield a new Response object
+      # for each one of them
+      def handle_collection
+        items.map do |item|
+          yield(Response.new(item))
+        end
+      end
+
+      # Determines if the response is a successful one or not
+      def success?
+        !error
+      end
+
+      # Handles the case of an error response
+      def handle_error
+        api_error = Error.new(error['message'] || error.inspect)
+        # Keep track of the original error code and response object
+        # for clients to have access to them if they rescue the exception
+        api_error.code = error['code']
+        api_error.api_response = self
+
+        raise api_error
+      end
+    end
+  end
+end

data/lib/social_post.rb

@@ -0,0 +1,37 @@
+# Class that represents a social post resource from the VerticalResponse API.
+# It has the ability to make REST calls to the API, as well as to wrap
+# the social post objects we get as response.
+#
+# NOTE: This class does not necessarily include all the available methods
+# the API has for the social post resource. You can consider this an initial approach
+# for an object oriented solution that you can expand according to your needs.
+
+require_relative 'resource'
+require_relative 'message'
+
+module VerticalResponse
+  module API
+    class SocialPost < Resource
+      class << self
+        # Base URI for the Email resource
+        def base_uri(*args)
+          @base_uri ||= File.join(super.to_s, 'messages', 'social_posts')
+        end
+
+        # Overwrite from parent class since it's a special type of
+        # resource name (with messages at the beginning)
+        def resource_name
+          'messages/social_posts'
+        end
+
+        # The SocialPost API does not support the 'all' method on its own for now.
+        # To get all social posts we need to do it through the Message API
+        def all(options = {})
+          Message.all(options.merge({ :message_type => MESSAGE_TYPE }))
+        end
+      end
+
+      MESSAGE_TYPE = 'social_post'
+    end
+  end
+end

data/lib/verticalresponse.rb

@@ -0,0 +1,21 @@
+require 'httparty'
+
+require_relative 'client.rb'
+require_relative 'contact.rb'
+require_relative 'custom_field.rb'
+require_relative 'email.rb'
+require_relative 'error.rb'
+require_relative 'list.rb'
+require_relative 'message.rb'
+require_relative 'oauth.rb'
+require_relative 'resource.rb'
+require_relative 'response.rb'
+require_relative 'social_post.rb'
+
+module VerticalResponse
+  CONFIG = { 
+    host: 'vrapi.verticalresponse.com',
+    port: "",
+    protocol: 'https'
+  }
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: verticalresponse
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Cosmin Atanasiu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-18 00:00:00.000000000 Z
+dependencies: []
+description: 'Gem used to connect to VerticalResponse.com''s API '
+email: cosmin@wishpond.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- lib/client.rb
+- lib/contact.rb
+- lib/custom_field.rb
+- lib/email.rb
+- lib/error.rb
+- lib/list.rb
+- lib/message.rb
+- lib/oauth.rb
+- lib/resource.rb
+- lib/response.rb
+- lib/social_post.rb
+- lib/verticalresponse.rb
+homepage: 
+licenses:
+- GPLv3
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Gem used to connect to VerticalResponse.com's API
+test_files: []