github_api 0.3.4 → 0.3.5

data/features/github_api.feature

@@ -1,50 +0,0 @@
-Feature: Github API components
-
-  In order to interact with full Github API
-  A user needs to request a Github class instance
-
-  Scenario: Accessing repositories API
-    Given I have github instance
-    When  I fetch "repos"
-    Then  I will have access to "Github::Repos" API
-
-  Scenario: Accessing organizations API
-    Given I have github instance
-    When  I fetch "orgs"
-    Then  I will have access to "Github::Orgs" API
-
-  Scenario: Accessing gists API
-    Given I have github instance
-    When  I fetch "gists"
-    Then  I will have access to "Github::Gists" API
-
-  Scenario: Accessing issues API
-    Given I have github instance
-    When  I fetch "issues"
-    Then  I will have access to "Github::Issues" API
-
-  Scenario: Accessing pull requests API
-    Given I have github instance
-    When  I fetch "pull_requests"
-    Then  I will have access to "Github::PullRequests" API
-
-  Scenario: Accessing git data API
-    Given I have github instance
-    When  I fetch "git_data"
-    Then  I will have access to "Github::GitData" API
-
-  Scenario: Accessing users API
-    Given I have github instance
-    When  I fetch "users"
-    Then  I will have access to "Github::Users" API
-
-  Scenario: Accessing users API
-    Given I have github instance
-    When  I fetch "events"
-    Then  I will have access to "Github::Events" API
-
-  Scenario: Accessing authorizations API
-    Given I have github instance
-    When  I fetch "oauth"
-    Then  I will have access to "Github::Authorizations" API
-

data/features/step_definitions/github_api_steps.rb

@@ -1,11 +0,0 @@
-Given /^I have github instance$/ do
-  @github = Github.new
-end
-
-When /^I fetch "([^"]*)"$/ do |method|
-  @response = @github.send(method.to_sym)
-end
-
-When /^I will have access to "([^"]*)" API$/ do |api|
-  @response.class.to_s.should match api
-end

data/features/support/env.rb

@@ -1,13 +0,0 @@
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'github_api'
-
-require 'rspec/expectations'

data/lib/github_api.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-require 'github_api/version'
-require 'github_api/configuration'
-require 'github_api/connection'
-
-module Github
-  extend Configuration
-
-  class << self
-    # Alias for Github::Client.new
-    #
-    # @return [Github::Client]
-    def new(options = {})
-      Github::Client.new(options)
-    end
-
-    # Delegate to Github::Client
-    #
-    def method_missing(method, *args, &block)
-      return super unless new.respond_to?(method)
-      new.send(method, *args, &block)
-    end
-
-    def respond_to?(method, include_private = false)
-      new.respond_to?(method, include_private) || super(method, include_private)
-    end
-
-  end
-
-  module AutoloadHelper
-
-    def autoload_all(prefix, options)
-      options.each do |const_name, path|
-        autoload const_name, File.join(prefix, path)
-      end
-    end
-
-    def register_constant(options)
-      options.each do |const_name, value|
-        const_set const_name.upcase.to_s, value
-      end
-    end
-
-    def lookup_constant(const_name)
-      const_get const_name.upcase.to_s
-    end
-
-  end
-
-  extend AutoloadHelper
-
-  autoload_all 'github_api',
-    :API          => 'api',
-    :Client       => 'client',
-    :Repos        => 'repos',
-    :Request      => 'request',
-    :Response     => 'response',
-    :Result       => 'result',
-    :Error        => 'error',
-    :Issues       => 'issues',
-    :Gists        => 'gists',
-    :GitData      => 'git_data',
-    :Orgs         => 'orgs',
-    :PullRequests => 'pull_requests',
-    :Users        => 'users',
-    :Events       => 'events',
-    :CoreExt      => 'core_ext',
-    :MimeType     => 'mime_type',
-    :Authorization => 'authorization',
-    :Authorizations => 'authorizations'
-
-end # Github

data/lib/github_api/api.rb

@@ -1,175 +0,0 @@
-# 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

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

data/lib/github_api/authorization.rb

@@ -1,73 +0,0 @@
-# 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

@@ -1,119 +0,0 @@
-# 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