plangrade-ruby 0.0.2

data/lib/plangrade/error.rb

@@ -0,0 +1,61 @@
+module Plangrade
+  module Error
+
+    class << self
+      def from_status(status=nil)
+        case status
+        when 400
+          BadRequest
+        when 401
+          Unauthorized
+        when 403
+          Forbidden
+        when 404
+          NotFound
+        when 406
+          NotAcceptable
+        when 429
+          RateLimitExceeded
+        when 500
+          InternalServerError
+        when 502
+          BadGateway
+        when 503
+          ServiceUnavailable
+        else
+          ApiError
+        end
+      end
+    end
+
+    # Raised when Plangrade returns unknown HTTP status code
+    class ApiError < StandardError;  end
+
+    # Raised when Plangrade returns the HTTP status code 400
+    class BadRequest < ApiError; end
+
+    # Raised when Plangrade returns the HTTP status code 401
+    class Unauthorized < ApiError; end
+
+    # Raised when Plangrade returns the HTTP status code 403
+    class Forbidden < ApiError; end
+
+    # Raised when Plangrade returns the HTTP status code 404
+    class NotFound < ApiError; end
+
+    # Raised when Plangrade returns the HTTP status code 406
+    class NotAcceptable < ApiError; end
+
+    # Raised when Plangrade returns the HTTP status code 429
+    class RateLimitExceeded < ApiError; end
+
+    # Raised when Plangrade returns the HTTP status code 500
+    class InternalServerError < ApiError; end
+
+    # Raised when Plangrade returns the HTTP status code 502
+    class BadGateway < ApiError; end
+
+    # Raised when Plangrade returns the HTTP status code 503
+    class ServiceUnavailable < ApiError; end
+  end
+end

data/lib/plangrade/http_adapter.rb

@@ -0,0 +1,86 @@
+require 'restclient'
+require 'multi_json'
+require 'addressable/uri'
+
+module Plangrade
+  class HttpAdapter
+
+    def self.log=(output)
+      RestClient.log = output
+    end
+
+    attr_reader :site_url, :connection_options
+
+    def initialize(site_url, opts={})
+      unless site_url =~ /^https?/
+        raise ArgumentError, "site_url must include either http or https scheme"
+      end
+      @site_url = site_url
+      @connection_options = opts
+    end
+
+    # set the url to be used for creating an http connection
+    # @param url [string]
+    def site_url=(url)
+      @site_url = url
+      @host     = nil
+      @scheme   = nil
+    end
+
+    def host
+      @host ||= parsed_url.host
+    end
+
+    def scheme
+      @scheme ||= parsed_url.scheme
+    end
+
+    def absolute_url(path='')
+      "#{@site_url}#{path}"
+    end
+
+    def connection_options=(opts)
+      raise ArgumentError, 'expected Hash' unless opts.is_a?(Hash)
+      @connection_options = opts
+    end
+
+    def send_request(method, path, opts={})
+      begin
+        params  = opts.fetch(:params, {})
+
+        req_opts = self.connection_options.merge({
+          :method  => method,
+          :headers => opts.fetch(:headers, {})
+        })
+
+        case method
+        when :get, :delete
+          query = Addressable::URI.form_encode(params)
+          normalized_path = query.empty? ? path : [path, query].join("?")
+          req_opts[:url]  = absolute_url(normalized_path)
+        when :post, :put
+          req_opts[:payload] = params
+          req_opts[:url]     = absolute_url(path)
+        else
+          raise "Unsupported HTTP method, #{method}"
+        end
+
+        resp = RestClient::Request.execute(req_opts)
+      
+        result = Plangrade::ApiResponse.new(resp.headers, resp.body, resp.code)
+      rescue => e
+        if e.is_a?(RestClient::ExceptionWithResponse)
+          e.response
+        else
+          raise e
+        end
+      end
+    end
+
+  private
+    def parsed_url
+      Addressable::URI.parse(@site_url)
+    end
+
+  end
+end

data/lib/plangrade/oauth2_client.rb

@@ -0,0 +1,79 @@
+require 'oauth2-client'
+
+module Plangrade
+  class OAuth2Client < OAuth2Client::Client
+
+    SITE_URL       = 'https://plangrade.com'
+    TOKEN_PATH     = '/oauth/token'
+    AUTHORIZE_PATH = '/oauth/authorize'
+
+    def initialize(client_id, client_secret, opts={})
+      site_url = opts.delete(:site_url) || SITE_URL
+      opts[:token_path]     ||= TOKEN_PATH
+      opts[:authorize_path] ||= AUTHORIZE_PATH
+      super(site_url, client_id, client_secret, opts)
+      yield self if block_given?
+      self
+    end
+
+    # Generates the Plangrade URL that the user will be redirected to in order to
+    # authorize your application
+    #
+    # @see http://docs.plangrade.com/#request-authorization
+    #
+    # @opts [Hash] additional parameters to be include in URL eg. scope, state, etc
+    #
+    # >> client = Plangrade::OAuth2Client.new('ETSIGVSxmgZitijWZr0G6w', '4bJZY38TCBB9q8IpkeualA2lZsPhOSclkkSKw3RXuE')
+    # >> client.webclient_authorization_url({
+    #      :redirect_uri => 'http://localhost:3000/auth/plangrade/callback',
+    #    })
+    # >> https://plangrade.com/oauth/authorize/?client_id={client_id}&
+    #    redirect_uri=http%3A%2F%2Flocalhost%3A3000%2Fauth%2F%2Fplangrade%2Fcallback&response_type=token
+    #
+    def webclient_authorization_url(opts={})
+      implicit.token_url(opts)
+    end
+
+    # Generates the Plangrade URL that the user will be redirected to in order to
+    # authorize your application
+    #
+    # @see http://docs.plangrade.com/#request-authorization
+    #
+    # @opts [Hash] additional parameters to be include in URL eg. scope, state, etc
+    #
+    # >> client = Plangrade::OAuth2Client.new('ETSIGVSxmgZitijWZr0G6w', '4bJZY38TCBB9q8IpkeualA2lZsPhOSclkkSKw3RXuE')
+    # >> client.webserver_authorization_url({
+    #      :redirect_uri => 'http://localhost:3000/auth/plangrade/callback',
+    #    })
+    # >> https://plangrade.com/oauth/authorize/?client_id={client_id}&
+    #    redirect_uri=http%3A%2F%2Flocalhost%3A3000%2Fauth%2Fplangrade%2Fcallback&response_type=code
+    #
+    def webserver_authorization_url(opts={})
+      opts[:scope] = normalize_scope(opts[:scope]) if opts[:scope]
+      authorization_code.authorization_url(opts)
+    end
+
+    # Makes a request to Plangrade server that will swap your authorization code for an access
+    # token
+    #
+    # @see http://docs.plangrade.com/#finish-authorization
+    #
+    # @opts [Hash] may include redirect uri and other query parameters
+    #
+    # >> client = PlangradeClient.new(config)
+    # >> client.access_token_from_authorization_code('G3Y6jU3a', {
+    #      :redirect_uri => 'http://localhost:3000/auth/plangrade/callback',
+    #    })
+    #
+    # POST /oauth2/access_token HTTP/1.1
+    # Host: www.plangrade.com
+    # Content-Type: application/x-www-form-urlencoded
+
+    #  client_id={client_id}&code=G3Y6jU3a&grant_type=authorization_code&
+    #  redirect_uri=http%3A%2F%2Flocalhost%3A3000%2Fauth%2Fplangrade%2Fcallback&client_secret={client_secret}
+    def access_token_from_authorization_code(code, opts={})
+      opts[:authenticate] ||= :body
+      authorization_code.get_token(code, opts)
+    end
+  end
+end

data/lib/plangrade/resources.rb

@@ -0,0 +1,5 @@
+require 'plangrade/resources/identity_map'
+require 'plangrade/resources/base'
+require 'plangrade/resources/user'
+require 'plangrade/resources/company'
+require 'plangrade/resources/participant'

data/lib/plangrade/resources/base.rb

@@ -0,0 +1,196 @@
+module Plangrade
+  module Resources
+    class Base
+      class << self
+        include ApiHandler
+
+        # Returns the non-qualified class name
+        # @!scope class
+        def base_name
+          @base_name ||= begin
+            word = "#{name.split(/::/).last}"
+            word.gsub!(/::/, '/')
+            word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+            word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+            word.tr!("-", "_")
+            word.downcase!
+            word
+          end
+        end
+
+        # Fetches JSON reprsentation for object model with provided `id`
+        # and returns a model instance with attributes
+        # @return [Yammer::Base]
+        # @param id [Integer]
+        # @!scope class
+        def get(id)
+          attrs = fetch(id)
+          attrs ? new(attrs) : nil
+        end
+
+
+        # @!scope class
+        def fetch(id)
+          return unless identity_map
+          attributes = identity_map.get("#{base_name}_#{id}")
+          unless attributes
+            result = api_handler.send("get_#{base_name}", id)
+            attributes = result.empty? ? nil : result.body
+            unless attributes.empty?
+              identity_map.put("#{base_name}_#{id}", attributes)
+            end
+          end
+          attributes
+        end
+
+        # @!scope class
+        def identity_map
+          @identity_map ||= Plangrade::Resources::IdentityMap.new
+        end
+
+        # Returns a hash of all attributes that are meant to trigger an HTTP request 
+        # @!scope class
+        def model_attributes
+          @model_attributes ||= {}
+        end
+
+      protected
+
+        def attr_accessor_deffered(*symbols)
+          symbols.each do |key|
+            # track attributes that should trigger a fetch
+            model_attributes[key] = false
+
+            # getter
+            define_method(key.to_s) do
+              load_deferred_attribute!(key)
+              instance_variable_get("@#{key}")
+            end
+
+            # setter
+            define_method("#{key}=") do |value|
+              load_deferred_attribute!(key)
+              if persisted? && loaded?
+                @modified_attributes[key] = value
+              else
+                @attrs[key] = value
+              end
+              instance_variable_set("@#{key}", value)
+            end
+          end
+        end
+      end
+
+      attr_reader :id, :attrs
+
+      def initialize(props={})
+        @klass               = self.class
+        @modified_attributes = {}
+        @new_record          = true
+        @loaded              = false
+        @attrs               = props
+        self.id              = @attrs.delete(:id)
+        self.update(@attrs)
+
+        yield self if block_given?
+      end
+
+      def api_handler
+        @klass.api_handler
+      end
+
+      def base_name
+        @klass.base_name
+      end
+
+      def new_record?
+        @new_record
+      end
+
+      def persisted?
+        !new_record?
+      end
+
+      def changes
+        @modified_attributes
+      end
+
+      def modified?
+        !changes.empty?
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def load!
+        @attrs = @klass.fetch(@id)
+        @loaded = true
+        update(@attrs)
+        self
+      end
+
+      def reload!
+        reset!
+        load!
+      end
+
+      def save
+        return self if ((persisted? && @modified_attributes.empty?) || @attrs.empty?)
+
+        result = if new_record?
+          api_handler.send("create_#{base_name}", @attrs)
+        else
+          api_handler.send("update_#{base_name}", @id, @modified_attributes)
+        end
+        @modified_attributes = {}
+        self
+      end
+
+      def delete!
+        return if new_record?
+        result = api_handler.send("delete_#{base_name}", @id)
+        result.success?
+      end
+
+    private
+
+      def id=(model_id)
+        return if model_id.nil?
+        @id = model_id.to_i
+        @new_record = false
+      end
+
+      # clear the entire class
+      def reset!
+        @modified_attributes = {}
+        @attrs  = {}
+        @new_record = true
+        @loaded = false
+      end
+
+    protected
+      # loads model 
+      def load_deferred_attribute!(key)
+        if @attrs.empty? && persisted? && !loaded?
+          load!
+          if !@attrs.has_key?(key)
+            raise "The key: #{key} appears not to be supported for model: #{self.base_name} \n #{@attrs.keys.inspect}"
+          end
+        end
+      end
+
+      # set all fetchable attributes 
+      def update(attrs={})
+        attrs.each do |key, value|
+          send("#{key}=", value) if self.respond_to?("#{key}=")
+        end
+        if persisted? && !loaded?
+          @loaded = @klass.model_attributes.keys.inject(true) do |result, key|
+            result && @attrs.has_key?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plangrade/resources/company.rb

@@ -0,0 +1,19 @@
+module Plangrade
+  module Resources
+    class Company < Plangrade::Resources::Base
+
+      def self.create(ein, name)
+        result = api_handler.create_company(:ein => ein, :name => name)
+        return nil unless result.created?
+        id = result.headers[:location].split('/').last.to_i
+        new(:id => id)
+      end
+
+      attr_accessor_deffered :id, :name, :ein, :grade
+
+      def update!(params)
+        api_handler.update_company(@id, params)
+      end
+    end
+  end
+end