hackeroo 0.1.0

data/lib/hackeroo/api/utils.rb

@@ -0,0 +1,187 @@
+require 'hackeroo/api/arguments'
+require 'hackeroo/cursor'
+require 'hackeroo/user'
+
+module Hackeroo
+  module API
+    module Utils
+
+      DEFAULT_CURSOR = -1
+
+    private
+
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param args [Array]
+      # @return [Array<Hackeroo::User>]
+      def threaded_user_objects_from_response(request_method, path, args)
+        arguments = Hackeroo::API::Arguments.new(args)
+        arguments.flatten.threaded_map do |user|
+          object_from_response(Hackeroo::User, request_method, path, merge_user(arguments.options, user))
+        end
+      end
+
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param args [Array]
+      # @return [Array<Hackeroo::User>]
+      def user_objects_from_response(request_method, path, args)
+        arguments = Hackeroo::API::Arguments.new(args)
+        merge_user!(arguments.options, arguments.pop || screen_name) unless arguments.options[:user_id] || arguments.options[:screen_name]
+        objects_from_response(Hackeroo::User, request_method, path, arguments.options)
+      end
+
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param args [Array]
+      # @return [Array]
+      def objects_from_response_with_user(klass, request_method, path, args)
+        arguments = Hackeroo::API::Arguments.new(args)
+        merge_user!(arguments.options, arguments.pop)
+        objects_from_response(klass, request_method, path, arguments.options)
+      end
+
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param options [Hash]
+      # @return [Array]
+      def objects_from_response(klass, request_method, path, options={})
+        response = send(request_method.to_sym, path, options)[:body]
+        objects_from_array(klass, response)
+      end
+
+      # @param klass [Class]
+      # @param array [Array]
+      # @return [Array]
+      def objects_from_array(klass, array)
+        array.map do |element|
+          klass.fetch_or_new(element)
+        end
+      end
+
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param args [Array]
+      # @return [Array]
+      def threaded_object_from_response(klass, request_method, path, args)
+        arguments = Hackeroo::API::Arguments.new(args)
+        arguments.flatten.threaded_map do |id|
+          object_from_response(klass, request_method, path, arguments.options.merge(:id => id))
+        end
+      end
+
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param options [Hash]
+      # @return [Object]
+      def object_from_response(klass, request_method, path, options={})
+        response = send(request_method.to_sym, path, options)
+        klass.from_response(response)
+      end
+
+      # @param collection_name [Symbol]
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param args [Array]
+      # @param method_name [Symbol]
+      # @return [Hackeroo::Cursor]
+      def cursor_from_response_with_user(collection_name, klass, request_method, path, args, method_name)
+        arguments = Hackeroo::API::Arguments.new(args)
+        merge_user!(arguments.options, arguments.pop || screen_name) unless arguments.options[:user_id] || arguments.options[:screen_name]
+        cursor_from_response(collection_name, klass, request_method, path, arguments.options, method_name)
+      end
+
+      # @param collection_name [Symbol]
+      # @param klass [Class]
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param options [Hash]
+      # @param method_name [Symbol]
+      # @return [Hackeroo::Cursor]
+      def cursor_from_response(collection_name, klass, request_method, path, options, method_name)
+        merge_default_cursor!(options)
+        response = send(request_method.to_sym, path, options)
+        Hackeroo::Cursor.from_response(response, collection_name.to_sym, klass, self, method_name, options)
+      end
+
+      def handle_forbidden_error(klass, error)
+        if error.message == klass::MESSAGE
+          raise klass.new
+        else
+          raise error
+        end
+      end
+
+      def merge_default_cursor!(options)
+        options[:cursor] = DEFAULT_CURSOR unless options[:cursor]
+      end
+
+      def screen_name
+        @screen_name ||= verify_credentials.screen_name
+      end
+
+      # Take a user and merge it into the hash with the correct key
+      #
+      # @param hash [Hash]
+      # @param user [Integer, String, Hackeroo::User] A Hackeroo user ID, screen_name, or object.
+      # @return [Hash]
+      def merge_user(hash, user, prefix=nil)
+        merge_user!(hash.dup, user, prefix)
+      end
+
+      # Take a user and merge it into the hash with the correct key
+      #
+      # @param hash [Hash]
+      # @param user [Integer, String, Hackeroo::User] A Hackeroo user ID, screen_name, or object.
+      # @return [Hash]
+      def merge_user!(hash, user, prefix=nil)
+        case user
+        when Integer
+          hash[[prefix, "user_id"].compact.join("_").to_sym] = user
+        when String
+          hash[[prefix, "screen_name"].compact.join("_").to_sym] = user
+        when Hackeroo::User
+          hash[[prefix, "user_id"].compact.join("_").to_sym] = user.id
+        end
+        hash
+      end
+
+      # Take a multiple users and merge them into the hash with the correct keys
+      #
+      # @param hash [Hash]
+      # @param users [Array<Integer, String, Hackeroo::User>, Set<Integer, String, Hackeroo::User>] An array of Hackeroo user IDs, screen_names, or objects.
+      # @return [Hash]
+      def merge_users(hash, users)
+        merge_users!(hash.dup, users)
+      end
+
+      # Take a multiple users and merge them into the hash with the correct keys
+      #
+      # @param hash [Hash]
+      # @param users [Array<Integer, String, Hackeroo::User>, Set<Integer, String, Hackeroo::User>] An array of Hackeroo user IDs, screen_names, or objects.
+      # @return [Hash]
+      def merge_users!(hash, users)
+        user_ids, screen_names = [], []
+        users.flatten.each do |user|
+          case user
+          when Integer
+            user_ids << user
+          when String
+            screen_names << user
+          when Hackeroo::User
+            user_ids << user.id
+          end
+        end
+        hash[:user_id] = user_ids.join(',') unless user_ids.empty?
+        hash[:screen_name] = screen_names.join(',') unless screen_names.empty?
+        hash
+      end
+
+    end
+  end
+end

data/lib/hackeroo/artist.rb

@@ -0,0 +1,7 @@
+require 'hackeroo/base'
+require 'hackeroo/error/identity_map_key_error'
+
+module Hackeroo
+  class Artist < Hackeroo::Base
+  end
+end

data/lib/hackeroo/base.rb

@@ -0,0 +1,125 @@
+require 'hackeroo/error/identity_map_key_error'
+
+module Hackeroo
+  class Base
+    # Define methods that retrieve the value from an initialized instance variable Hash, using the attribute as a key
+    #
+    # @param attrs [Array, Set, Symbol]
+    def self.attr_reader(*attrs)
+      mod = Module.new do
+        attrs.each do |attribute|
+          define_method attribute do
+            @attrs[attribute.to_sym]
+          end
+          define_method "#{attribute}?" do
+            !!@attrs[attribute.to_sym]
+          end
+        end
+      end
+      const_set(:Attributes, mod)
+      include mod
+    end
+
+    # return [Hackeroo::IdentityMap]
+    def self.identity_map
+      return unless Hackeroo.identity_map
+      @identity_map = Hackeroo.identity_map.new unless defined?(@identity_map) && @identity_map.class == Hackeroo.identity_map
+      @identity_map
+    end
+
+    # Retrieves an object from the identity map.
+    #
+    # @param attrs [Hash]
+    # @return [Hackeroo::Base]
+    def self.fetch(attrs)
+      return unless identity_map
+      if object = identity_map.fetch(Marshal.dump(attrs))
+        return object
+      end
+      return yield if block_given?
+      raise Hackeroo::Error::IdentityMapKeyError, "key not found"
+    end
+
+    # Stores an object in the identity map.
+    #
+    # @param object [Object]
+    # @return [Hackeroo::Base]
+    def self.store(object)
+      return object unless identity_map
+      identity_map.store(Marshal.dump(object.attrs), object)
+    end
+
+    # Returns a new object based on the response hash
+    #
+    # @param response [Hash]
+    # @return [Hackeroo::Base]
+    def self.from_response(response={})
+      fetch_or_new(response[:body])
+    end
+
+    # Retrieves an object from the identity map, or stores it in the
+    # identity map if it doesn't already exist.
+    #
+    # @param attrs [Hash]
+    # @return [Hackeroo::Base]
+    def self.fetch_or_new(attrs={})
+      return unless attrs
+      return new(attrs) unless identity_map
+
+      fetch(attrs) do
+        object = new(attrs)
+        store(object)
+      end
+    end
+
+    # Initializes a new object
+    #
+    # @param attrs [Hash]
+    # @return [Hackeroo::Base]
+    def initialize(attrs={})
+      @attrs = attrs
+    end
+
+    # Fetches an attribute of an object using hash notation
+    #
+    # @param method [String, Symbol] Message to send to the object
+    def [](method)
+      send(method.to_sym)
+    rescue NoMethodError
+      nil
+    end
+
+    # Retrieve the attributes of an object
+    #
+    # @return [Hash]
+    def attrs
+      @attrs
+    end
+    alias to_hash attrs
+
+    # Update the attributes of an object
+    #
+    # @param attrs [Hash]
+    # @return [Hackeroo::Base]
+    def update(attrs)
+      @attrs.update(attrs)
+      self
+    end
+
+  protected
+
+    # @param attr [Symbol]
+    # @param other [Hackeroo::Base]
+    # @return [Boolean]
+    def attr_equal(attr, other)
+      self.class == other.class && !other.send(attr).nil? && send(attr) == other.send(attr)
+    end
+
+    # @param other [Hackeroo::Base]
+    # @return [Boolean]
+    def attrs_equal(other)
+      self.class == other.class && !other.attrs.empty? && attrs == other.attrs
+    end
+
+  end
+end

data/lib/hackeroo/client.rb

@@ -0,0 +1,73 @@
+require 'faraday'
+require 'multi_json'
+require 'hackeroo/api/users'
+require 'hackeroo/api/performances'
+require 'hackeroo/api/stages'
+require 'hackeroo/api/artists'
+require 'hackeroo/configurable'
+require 'hackeroo/error/client_error'
+require 'hackeroo/error/decode_error'
+require 'base64'
+require 'uri'
+
+module Hackeroo
+  # Wrapper for the Hackeroo REST API
+  #
+  # @note All methods have been separated into modules and follow the same grouping used in {http://dev.hackeroo.com/doc the Hackeroo API Documentation}.
+  # @see http://dev.hackeroo.com/pages/every_developer
+  class Client
+    include Hackeroo::API::Users
+    include Hackeroo::API::Performances
+    include Hackeroo::API::Stages
+    include Hackeroo::API::Artists
+    include Hackeroo::Configurable
+
+    # Initializes a new Client object
+    #
+    # @param options [Hash]
+    # @return [Hackeroo::Client]
+    def initialize(options={})
+      Hackeroo::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || Hackeroo.instance_variable_get(:"@#{key}"))
+      end
+    end
+
+    # Perform an HTTP GET request
+    def get(path, params={})
+      request(:get, path, params)
+    end
+
+  private
+
+    # Returns a proc that can be used to setup the Faraday::Request headers
+    #
+    # @param method [Symbol]
+    # @param path [String]
+    # @param params [Hash]
+    # @return [Proc]
+    def request_setup(method, path, params)
+      Proc.new do |request|
+        request.headers['x-app-id'] = @clientkey
+        request.headers[:content_type] = 'application/json'
+        request.headers[:accept] = 'application/json'
+      end
+    end
+
+    def request(method, path, params={}, signature_params=params)
+      request_setup = request_setup(method, path, params)
+      connection.send(method.to_sym, path, params, &request_setup).env
+    rescue Faraday::Error::ClientError
+      raise Hackeroo::Error::ClientError
+    rescue MultiJson::DecodeError
+      raise Hackeroo::Error::DecodeError
+    end
+
+    # Returns a Faraday::Connection object
+    #
+    # @return [Faraday::Connection]
+    def connection
+      @connection ||= Faraday.new(@endpoint, @connection_options.merge(:builder => @middleware))
+    end
+
+  end
+end

data/lib/hackeroo/configurable.rb

@@ -0,0 +1,87 @@
+require 'forwardable'
+require 'hackeroo/error/configuration_error'
+
+module Hackeroo
+  module Configurable
+    extend Forwardable
+    attr_accessor :clientkey, :endpoint, :connection_options, :identity_map, :middleware
+    def_delegator :options, :hash
+
+    class << self
+
+      def keys
+        @keys ||= [
+          :clientkey,
+          :endpoint,
+          :connection_options,
+          :identity_map,
+          :middleware,
+        ]
+      end
+
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    #
+    # @raise [Hackeroo::Error::ConfigurationError] Error is raised when supplied
+    #   hackeroo credentials are not a String or Symbol.
+    def configure
+      yield self
+      validate_credential_type!
+      self
+    end
+
+    def reset!
+      Hackeroo::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Hackeroo::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    # @return [Boolean]
+    def user_token?
+      !!(@oauth_token && @oauth_token_secret)
+    end
+
+    # @return [Boolean]
+    def bearer_token?
+      !!@bearer_token
+    end
+
+    # @return [Boolean]
+    def credentials?
+      credentials.values.all? || bearer_token?
+    end
+
+  private
+
+    # @return [Hash]
+    def credentials
+      {
+        :clientkey    => @clientkey,
+      }
+    end
+
+    # @return [Hash]
+    def options
+      Hash[Hackeroo::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+    # Ensures that all credentials set during configuration are of a
+    # valid type. Valid types are String and Symbol.
+    #
+    # @raise [Hackeroo::Error::ConfigurationError] Error is raised when
+    #   supplied hackeroo credentials are not a String or Symbol.
+    def validate_credential_type!
+      credentials.each do |credential, value|
+        next if value.nil?
+
+        unless value.is_a?(String) || value.is_a?(Symbol)
+          raise(Error::ConfigurationError, "Invalid #{credential} specified: #{value} must be a string or symbol.")
+        end
+      end
+    end
+
+  end
+end