github_api 0.3.5 → 0.3.6

data/lib/github_api/compatibility.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+if RUBY_VERSION < "1.9"
+
+  def ruby_18 #:nodoc:
+    yield
+  end
+
+  def ruby_19 #:nodoc:
+    false
+  end
+
+else
+
+  def ruby_18 #:nodoc:
+    false
+  end
+
+  def ruby_19 #:nodoc:
+    yield
+  end
+
+end

data/lib/github_api/configuration.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+module Github
+  module Configuration
+
+    VALID_OPTIONS_KEYS = [
+      :adapter,
+      :client_id,
+      :client_secret,
+      :oauth_token,
+      :endpoint,
+      :mime_type,
+      :user_agent,
+      :connection_options,
+      :repo,
+      :user,
+      :login,
+      :password,
+      :basic_auth
+    ].freeze
+
+    # Other adapters are :typhoeus, :patron, :em_synchrony, :excon, :test
+    DEFAULT_ADAPTER = :net_http
+
+    # By default, don't set an application key
+    DEFAULT_CLIENT_ID = nil
+
+    # By default, don't set an application secret
+    DEFAULT_CLIENT_SECRET = nil
+
+    # By default, don't set a user oauth access token
+    DEFAULT_OAUTH_TOKEN = nil
+
+    # By default, don't set a user login name
+    DEFAULT_LOGIN = nil
+
+    # By default, don't set a user password
+    DEFAULT_PASSWORD = nil
+
+    # By default, don't set a user basic authentication
+    DEFAULT_BASIC_AUTH = nil
+
+    # The endpoint used to connect to GitHub if none is set
+    DEFAULT_ENDPOINT = 'https://api.github.com'.freeze
+
+    # The value sent in the http header for 'User-Agent' if none is set
+    DEFAULT_USER_AGENT = "Github Ruby Gem #{Github::VERSION::STRING}".freeze
+
+    # By default the <tt>Accept</tt> header will make a request for <tt>JSON</tt>
+    DEFAULT_MIME_TYPE = :json
+
+    # By default uses the Faraday connection options if none is set
+    DEFAULT_CONNECTION_OPTIONS = {}
+
+    # By default, don't set user name
+    DEFAULT_USER = nil
+
+    # By default, don't set repository name
+    DEFAULT_REPO = nil
+
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    # Convenience method to allow for global setting of configuration options
+    def configure
+      yield self
+    end
+
+    def self.extended(base)
+      base.set_defaults
+    end
+
+    def options
+      options = {}
+      VALID_OPTIONS_KEYS.each { |k| options[k] = send(k) }
+      options
+    end
+
+    def set_defaults
+      self.adapter            = DEFAULT_ADAPTER
+      self.client_id          = DEFAULT_CLIENT_ID
+      self.client_secret      = DEFAULT_CLIENT_SECRET
+      self.oauth_token        = DEFAULT_OAUTH_TOKEN
+      self.endpoint           = DEFAULT_ENDPOINT
+      self.user_agent         = DEFAULT_USER_AGENT
+      self.connection_options = DEFAULT_CONNECTION_OPTIONS
+      self.mime_type          = DEFAULT_MIME_TYPE
+      self.user               = DEFAULT_USER
+      self.repo               = DEFAULT_REPO
+      self.login              = DEFAULT_LOGIN
+      self.password           = DEFAULT_PASSWORD
+      self.basic_auth         = DEFAULT_BASIC_AUTH
+      self
+    end
+
+  end # Configuration
+end # Github

data/lib/github_api/connection.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'github_api/response'
+require 'github_api/response/mashify'
+require 'github_api/response/jsonize'
+require 'github_api/response/helpers'
+require 'github_api/response/raise_error'
+require 'github_api/request/oauth2'
+require 'github_api/request/basic_auth'
+
+module Github
+  module Connection
+
+  ALLOWED_OPTIONS = [
+    :headers,
+    :url,
+    :params,
+    :request,
+    :ssl
+  ].freeze
+
+  private
+
+    def default_options(options={}) # :nodoc:
+      {
+        :headers => {
+          'Accept'       => '*/*', #accepts,
+          'User-Agent'   => user_agent,
+          'Content-Type' => 'application/x-www-form-urlencoded'
+        },
+        :ssl => { :verify => false },
+        :url => endpoint
+      }
+    end
+
+    def clear_cache # :nodoc:
+      @connection = nil
+    end
+
+    def caching? # :nodoc:
+      !@connection.nil?
+    end
+
+    def connection(options = {}) # :nodoc:
+
+      merged_options = _filter_params_keys(ALLOWED_OPTIONS, default_options.merge(options))
+      clear_cache unless options.empty?
+
+      @connection ||= begin
+        Faraday.new(merged_options.merge(connection_options)) do |builder|
+          puts options.inspect
+
+          builder.use Faraday::Request::JSON
+          builder.use Faraday::Request::Multipart
+          builder.use Faraday::Request::UrlEncoded
+          builder.use Faraday::Response::Logger
+
+          builder.use Github::Request::OAuth2, oauth_token if oauth_token?
+          builder.use Github::Request::BasicAuth, authentication if basic_authed?
+
+          builder.use Github::Response::Helpers
+          unless options[:raw]
+            builder.use Github::Response::Mashify
+            builder.use Github::Response::Jsonize
+          end
+
+          builder.use Github::Response::RaiseError
+          builder.adapter adapter
+        end
+      end
+    end
+
+  end # Connection
+end # Github

data/lib/github_api/core_ext/array.rb

@@ -0,0 +1,14 @@
+class Array # :nodoc:
+
+  def except(*keys) # :nodoc:
+    puts "module except works!!!"
+    self.dup.except!(*keys)
+  end unless method_defined?(:except)
+
+  def except!(*items) # :nodoc:
+    copy = self.dup
+    copy.reject! { |item| items.include? item }
+    copy
+  end unless method_defined?(:except!)
+
+end # Hash

data/lib/github_api/core_ext/hash.rb

@@ -0,0 +1,42 @@
+class Hash # :nodoc:
+
+  def except(*items) # :nodoc:
+    puts "array except works!!!"
+    self.dup.except!(*items)
+  end unless method_defined?(:except)
+
+  def except!(*keys) # :nodoc:
+    copy = self.dup
+    keys.each { |key| copy.delete!(key) }
+    copy
+  end unless method_defined?(:except!)
+
+  def symbolize_keys  # :nodoc:
+    inject({}) do |hash, (key, value)|
+      hash[(key.to_sym rescue key) || key] = value
+      hash
+    end
+  end
+
+  def symbolize_keys! # :nodoc:
+    hash = symbolize_keys
+    hash.each do |key, val|
+      hash[key] = case val
+        when Hash
+          val.symbolize_keys!
+        when Array
+          val.map do |item|
+            item.is_a?(Hash) ? item.symbolize_keys! : item
+          end
+        else
+          val
+        end
+    end
+    return hash
+  end unless method_defined?(:symbolize_keys!)
+
+  def serialize # :nodoc:
+    self.map { |key, val| [key, val].join("=") }.join("&")
+  end unless method_defined?(:serialize)
+
+end # Hash

data/lib/github_api/error.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Github
+  class Error < StandardError
+    attr_reader :response_message, :response_headers
+
+    def initialize(message, headers)
+      @response_message = message 
+      super message
+    end
+
+    def inspect
+      %(#<#{self.class}>)
+    end
+  end # Error
+
+  # Raised when Github returns the HTTP status code 400
+  class BadRequest < Error; end
+
+  # Raised when Github returns the HTTP status code 401
+  class Unauthorised < Error; end
+
+  # Raised when Github returns the HTTP status code 403
+  class Forbidden < Error; end 
+
+  # Raised when Github returns the HTTP status code 404
+  class ResourceNotFound < Error; end
+
+  # Raised when Github returns the HTTP status code 500
+  class InternalServerError < Error; end
+
+  # Raised when Github returns the HTTP status code 503
+  class ServiceUnavailable < Error; end
+
+end # Github

data/lib/github_api/events.rb

@@ -0,0 +1,202 @@
+# encoding: utf-8
+
+module Github
+  class Events < API
+
+    # Creates new Gists API
+    def initialize(options = {})
+      super(options)
+    end
+
+    # List all public events
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.public
+    #  @github.events.public { |event| ... }
+    #
+    def public(params={})
+      _normalize_params_keys(params)
+
+      response = get("/events", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :public_events :public
+    alias :list_public :public
+    alias :list_public_events :public
+
+    # List all repository events for a given user
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.repository_events 'user-name', 'repo-name'
+    #  @github.events.repository_events 'user-name', 'repo-name' { |event| ... }
+    #
+    def repository(user_name=nil, repo_name=nil, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _normalize_params_keys(params)
+
+      response = get("/repos/#{user}/#{repo}/events", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :repos :repository
+    alias :repo_events :repository
+    alias :repository_events :repository
+    alias :list_repository_events :repository
+
+    # List all issue events for a given repository
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.issue 'user-name', 'repo-name'
+    #  @github.events.issue 'user-name', 'repo-name' { |event| ... }
+    #
+    def issue(user_name=nil, repo_name=nil, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _normalize_params_keys(params)
+
+      response = get("/repos/#{user}/#{repo}/issues/events", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :issues :issue
+    alias :issue_events :issue
+    alias :list_issue_events :issue
+
+    # List all public events for a network of repositories
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.network 'user-name', 'repo-name'
+    #  @github.events.network 'user-name', 'repo-name' { |event| ... }
+    #
+    def network(user_name=nil, repo_name=nil, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _normalize_params_keys(params)
+
+      response = get("/networks/#{user}/#{repo}/events", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :repo_network :network
+    alias :repository_network :network
+    alias :list_repo_network_events :network
+    alias :list_repository_network_events :network
+
+    # List all public events for an organization
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.org 'org-name'
+    #  @github.events.org 'org-name' { |event| ... }
+    #
+    def org(org_name, params={})
+      _validate_presence_of org_name
+      _normalize_params_keys(params)
+
+      response = get("/orgs/#{org_name}/events", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :organization :org
+    alias :list_orgs :org
+    alias :list_org_events :org
+    alias :list_organization_events :org
+
+    # List all events that a user has received
+    #
+    # These are events that you’ve received by watching repos and following users.
+    # If you are authenticated as the given user, you will see private events. 
+    # Otherwise, you’ll only see public events.
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.received 'user-name'
+    #  @github.events.received 'user-name' { |event| ... }
+    #
+    # List all public events that a user has received
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.received 'user-name', :public => true
+    #  @github.events.received 'user-name', :public => true { |event| ... }
+    #
+    def received(user_name, params={})
+      _validate_presence_of user_name
+      _normalize_params_keys(params)
+
+      public_events = if params['public']
+        params.delete('public')
+        '/public'
+      end
+
+      response = get("/users/#{user_name}/received_events#{public_events}", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :user_received :received
+    alias :list_user_received :received
+
+    # List all events that a user has performed
+    #
+    # If you are authenticated as the given user, you will see your private
+    # events. Otherwise, you’ll only see public events.
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.performed 'user-name'
+    #  @github.events.performed 'user-name' { |event| ... }
+    #
+    # List all public events that a user has performed
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.performed 'user-name', :public => true
+    #  @github.events.performed 'user-name', :public => true { |event| ... }
+    #
+    def performed(user_name, params={})
+      _validate_presence_of user_name
+      _normalize_params_keys(params)
+
+      public_events = if params['public']
+        params.delete('public')
+        '/public'
+      end
+
+      response = get("/users/#{user_name}/events#{public_events}", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :user_performed :performed
+    alias :list_user_performed :performed
+
+    # List all events for an organization
+    #
+    # This is the user’s organization dashboard. You must be authenticated
+    # as the user to view this.
+    #
+    # = Examples
+    #  @github = Github.new
+    #  @github.events.user_org 'user-name', 'org-name'
+    #  @github.events.user_org 'user-name', 'org-name' { |event| ... }
+    #
+    def user_org(user_name, org_name, params={})
+      _validate_presence_of user_name, org_name
+      _normalize_params_keys(params)
+
+      response = get("/users/#{user_name}/events/orgs/#{org_name}", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :user_organization :user_org
+    alias :list_user_org :user_org
+    alias :list_user_org_events :user_org
+    alias :list_user_organization_events :user_org
+
+  end # Events
+end # Github