github_api 0.3.4 → 0.3.5

data/lib/github_api/cache_control.rb

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

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

data/lib/github_api/compatibility.rb

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

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

@@ -1,81 +0,0 @@
-# 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 header_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:
-
-      # parse(options['resource'], options['mime_type'] || mime_type) if options['mime_type']
-#       merged_options = if connection_options.empty?
-#         header_options.merge(options)
-#       else
-#         connection_options.merge(header_options)
-#       end
-      merged_options = _filter_params_keys(ALLOWED_OPTIONS, header_options.merge(options))
-      clear_cache unless options.empty?
-
-      @connection ||= begin
-        Faraday.new(merged_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

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

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

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

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