github_api 0.3.5 → 0.3.6

data/lib/github_api/api.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+require 'github_api/configuration'
+require 'github_api/connection'
+require 'github_api/request'
+require 'github_api/mime_type'
+require 'github_api/core_ext/hash'
+require 'github_api/core_ext/array'
+require 'github_api/compatibility'
+
+module Github
+
+  # @private
+  class API
+    include Authorization
+    include MimeType
+    include Connection
+    include Request
+
+    VALID_API_KEYS = [
+      :per_page,
+      :pagination
+    ]
+
+    attr_reader *Configuration::VALID_OPTIONS_KEYS
+    attr_accessor *VALID_API_KEYS
+
+    # Callback to update global configuration options
+    class_eval do
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        define_method "#{key}=" do |arg|
+          self.instance_variable_set("@#{key}", arg)
+          Github.send("#{key}=", arg)
+        end
+      end
+    end
+
+    # Creates new API
+    def initialize(options = {})
+      options = Github.options.merge(options)
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+      _process_basic_auth(options[:basic_auth])
+      client if client_id? && client_secret?
+    end
+
+  private
+
+    # Extract login and password from basic_auth parameter
+    def _process_basic_auth(auth)
+      case auth
+      when String
+        login    = auth.split(':').first
+        password = auth.split(':').last
+      when Hash
+        login    = auth[:login]
+        password = auth[:password]
+      end
+    end
+
+    # Responds to attribute query
+    def method_missing(method, *args, &block) # :nodoc:
+      if method.to_s =~ /^(.*)\?$/
+        return !self.send($1.to_s).nil?
+      else
+        super
+      end
+    end
+
+    def _validate_inputs(required, provided) # :nodoc:
+      required.all? do |key|
+        provided.has_key? key
+      end
+    end
+
+    def _validate_presence_of(*params) # :nodoc:
+      params.each do |param|
+        raise ArgumentError, "parameter cannot be nil" if param.nil?
+      end
+    end
+
+    def _validate_user_repo_params(user_name, repo_name) # :nodoc:
+      raise ArgumentError, "[user] parameter cannot be nil" if user_name.nil?
+      raise ArgumentError, "[repo] parameter cannot be nil" if repo_name.nil?
+    end
+
+    def _update_user_repo_params(user_name, repo_name=nil) # :nodoc:
+      self.user = user_name || self.user
+      self.repo = repo_name || self.repo
+    end
+
+    def _merge_user_into_params!(params)  #  :nodoc:
+      params.merge!({ 'user' => self.user }) if user?
+    end
+
+    def _merge_user_repo_into_params!(params)   #  :nodoc:
+      { 'user' => self.user, 'repo' => self.repo }.merge!(params)
+    end
+
+    # Turns any keys from nested hashes including nested arrays into strings
+    def _normalize_params_keys(params)  #  :nodoc:
+      case params
+      when Hash
+        params.keys.each do |k|
+          params[k.to_s] = params.delete(k)
+          _normalize_params_keys(params[k.to_s])
+        end
+      when Array
+        params.map! do |el|
+          _normalize_params_keys(el)
+        end
+      else
+        params.to_s
+      end
+      return params
+    end
+
+    def _filter_params_keys(keys, params)  # :nodoc:
+      params.reject! { |k,v| !keys.include? k }
+    end
+
+    def _hash_traverse(hash, &block)
+      hash.each do |key, val|
+        block.call(key)
+        case val
+        when Hash
+          val.keys.each do |k|
+            _hash_traverse(val, &block)
+          end
+        when Array
+          val.each do |item|
+            _hash_traverse(item, &block)
+          end
+        end
+      end
+      return hash
+    end
+
+    def _validate_params_values(options, params)  # :nodoc:
+      params.each do |k, v|
+        next unless options.keys.include?(k)
+        if options[k].is_a?(Array) && !options[k].include?(params[k])
+          raise ArgumentError, "Wrong value for #{k}, allowed: #{options[k].join(', ')}"
+        elsif options[k].is_a?(Regexp) && !(options[k] =~ params[k])
+          raise ArgumentError, "String does not match the parameter value."
+        end
+      end
+    end
+
+    def _merge_mime_type(resource, params) # :nodoc:
+      params['resource'] = resource
+      params['mime_type'] = params['mime_type'] || :raw
+    end
+
+    # TODO add to core extensions
+    def _extract_parameters(array)
+      if array.last.is_a?(Hash) && array.last.instance_of?(Hash)
+        pop
+      else
+        {}
+      end
+    end
+
+    # Passes configuration options to instantiated class
+    def _create_instance(klass, options)
+      options.symbolize_keys!
+      klass.new(options)
+    end
+
+    def _token_required
+    end
+
+  end # API
+end # Github

data/lib/github_api/api/utils.rb

@@ -0,0 +1,9 @@
+module Github
+  class API
+    module Utils
+      
+      private
+
+    end
+  end
+end

data/lib/github_api/authorization.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module Github
+  module Authorization
+
+    attr_accessor :scopes
+
+    # Setup OAuth2 instance
+    def client
+      @client ||= ::OAuth2::Client.new(client_id, client_secret,
+        :site          => 'https://github.com',
+        :authorize_url => 'login/oauth/authorize',
+        :token_url     => 'login/oauth/access_token'
+      )
+    end
+
+    # Strategy token
+    def auth_code
+      _verify_client
+      @client.auth_code
+    end
+
+    # Sends authorization request to GitHub.
+    # = Parameters
+    # * <tt>:redirect_uri</tt> - Required string.
+    # * <tt>:scope</tt> - Optional string. Comma separated list of scopes.
+    #   Available scopes:
+    #   * (no scope) - public read-only access (includes public user profile info, public repo info, and gists).
+    #   * <tt>user</tt> - DB read/write access to profile info only.
+    #   * <tt>public_repo</tt> - DB read/write access, and Git read access to public repos.
+    #   * <tt>repo</tt> - DB read/write access, and Git read access to public and private repos.
+    #   * <tt>gist</tt> - write access to gists.
+    #
+    def authorize_url(params = {})
+      _verify_client
+      @client.auth_code.authorize_url(params)
+    end
+
+    # Makes request to token endpoint and retrieves access token value
+    def get_token(authorization_code, params = {})
+      _verify_client
+      @client.auth_code.get_token(authorization_code, params)
+    end
+
+    # Check whether authentication credentials are present
+    def authenticated?
+      basic_authed? || oauth_token?
+    end
+
+    # Check whether basic authentication credentials are present
+    def basic_authed?
+      basic_auth? || (login? && password?)
+    end
+
+    # Select authentication parameters
+    def authentication
+      if login? && password?
+        { :login => login, :password => password }
+      elsif basic_auth?
+        { :basic_auth => basic_auth }
+      else
+        { }
+      end
+    end
+
+    private
+
+    def _verify_client # :nodoc:
+      raise ArgumentError, 'Need to provide client_id and client_secret' unless client_id? && client_secret?
+    end
+
+  end # Authorization
+end # Github

data/lib/github_api/authorizations.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+module Github
+  class Authorizations < API
+
+    VALID_AUTH_PARAM_NAMES = %w[
+      scopes
+      add_scopes
+      remove_scopes
+    ].freeze
+
+    # Creates new OAuth Authorizations API
+    def initialize(options = {})
+      super(options)
+    end
+
+    # List authorizations
+    #
+    # = Examples
+    #  @github = Github.new :basic_auth => 'login:password'
+    #  @github.oauth.authorizations
+    #  @github.oauth.authorizations { |auth| ... }
+    #
+    def authorizations(params={})
+      _check_if_authenticated
+      _normalize_params_keys(params)
+
+      response = get("/authorizations", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :auths :authorizations
+    alias :list_auths :authorizations
+    alias :list_authorizations :authorizations
+
+    # Get a single authorization
+    #
+    # = Examples
+    #  @github = Github.new :basic_auth => 'login:password'
+    #  @github.oauth.authorization 'authorization-id'
+    #
+    def authorization(authorization_id, params={})
+      _validate_presence_of(authorization_id)
+      _check_if_authenticated
+      _normalize_params_keys params
+
+      get "/authorizations/#{authorization_id}", params
+    end
+    alias :auth :authorization
+    alias :get_auth :authorization
+    alias :get_authorization :authorization
+
+    # Create a new authorization
+    #
+    # = Inputs
+    # * <tt>:scopes</tt> - Optional array - A list of scopes that this authorization is in.
+    # = Examples
+    #  @github = Github.new :basic_auth => 'login:password'
+    #  @github.oauth.create_authorization
+    #    "scopes" => ["public_repo"]
+    #
+    def create_authorization(params={})
+      _check_if_authenticated
+      _normalize_params_keys(params)
+      _filter_params_keys(VALID_AUTH_PARAM_NAMES, params)
+
+      post("/authorizations", params)
+    end
+    alias :create_auth :create_authorization
+
+    # Update an existing authorization
+    #
+    # = Inputs
+    # * <tt>:scopes</tt> - Optional array - A list of scopes that this authorization is in.
+    # * <tt>:add_scopes</tt> - Optional array - A list of scopes to add to this authorization.
+    # * <tt>:remove_scopes</tt> - Optional array - A list of scopes to remove from this authorization.
+    #
+    # = Examples
+    #  @github = Github.new :basic_auth => 'login:password'
+    #  @github.oauth.update_authorization
+    #    "add_scopes" => ["repo"],
+    #
+    def update_authorization(authorization_id, params={})
+      _check_if_authenticated
+      _validate_presence_of(authorization_id)
+
+      _normalize_params_keys(params)
+      _filter_params_keys(VALID_AUTH_PARAM_NAMES, params)
+
+      patch("/authorizations/#{authorization_id}", params)
+    end
+    alias :update_auth :update_authorization
+
+    # Delete an authorization
+    #
+    # = Examples
+    #  @github.oauth.delete_authorization 'authorization-id'
+    #
+    def delete_authorization(authorization_id, params={})
+      _check_if_authenticated
+      _validate_presence_of(authorization_id)
+
+      _normalize_params_keys(params)
+      _filter_params_keys(VALID_AUTH_PARAM_NAMES, params)
+
+      delete("/authorizations/#{authorization_id}", params)
+    end
+    alias :delete_auth :delete_authorization
+    alias :remove_auth :delete_authorization
+    alias :remove_authorization :delete_authorization
+
+    private
+
+    def _check_if_authenticated
+      raise ArgumentError, 'You can only access authentication tokens through Basic Authentication' unless authenticated?
+    end
+
+  end # Authorizations
+end # Github

data/lib/github_api/cache_control.rb

@@ -0,0 +1,19 @@
+module Github
+  module CacheOptions
+    extend self
+
+    def self.option_accessor(key)
+      defined_method("#{key}=") { |value|  }
+    end
+
+  private 
+
+    def initialize_options(options={})
+      @default_options = {
+        'type' => :memoization,
+
+      }
+    end
+
+  end
+end

data/lib/github_api/client.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Github
+  class Client < API
+
+    def gists(options = {})
+      @gists ||= _create_instance Github::Gists, options
+    end
+
+    # The Git Database API gives you access to read and write raw Git objects
+    # to your Git database on GitHub and to list and update your references
+    # (branch heads and tags).
+    def git_data(options = {})
+      @git_data ||= _create_instance Github::GitData, options
+    end
+    alias :git :git_data
+
+    def issues(options = {})
+      @issues ||= _create_instance Github::Issues, options
+    end
+
+    def orgs(options = {})
+      @orgs ||= _create_instance Github::Orgs, options
+    end
+    alias :organizations :orgs
+
+    def pull_requests(options = {})
+      @pull_requests ||= _create_instance Github::PullRequests, options
+    end
+
+    def repos(options = {})
+      @repos ||= _create_instance Github::Repos, options
+    end
+    alias :repositories :repos
+
+    # Many of the resources on the users API provide a shortcut for getting 
+    # information about the currently authenticated user.
+    def users(options = {})
+      @users ||= _create_instance Github::Users, options
+    end
+
+    # This is a read-only API to the GitHub events.
+    # These events power the various activity streams on the site.
+    def events(options = {})
+      @events ||= _create_instance Github::Events, options
+    end
+
+    # An API for users to manage their own tokens. You can only access your own
+    # tokens, and only through Basic Authentication.
+    def oauth(options = {})
+      @oauth ||= _create_instance Github::Authorizations, options
+    end
+
+  end # Client
+end # Github