github_api 0.11.3 → 0.12.0

data/lib/github_api/api/factory.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'github_api/core_ext/hash'
+
+module Github
+  class API
+    class Factory
+
+      # Instantiates a new github api object
+      #
+      def self.new(klass, options={}, &block)
+        return create_instance(klass, options, &block) if klass
+        raise ArgumentError, 'must provide API class to be instantiated'
+      end
+
+      # Passes configuration options to instantiated class
+      #
+      def self.create_instance(klass, options, &block)
+        options.symbolize_keys!
+        convert_to_constant(klass.to_s).new options, &block
+      end
+
+      # Convert name to constant
+      #
+      def self.convert_to_constant(classes)
+        classes.split('::').inject(Github) do |constant, klass|
+          constant.const_get klass
+        end
+      end
+
+    end # Factory
+  end # Api
+end # Github

data/lib/github_api/client.rb

@@ -3,86 +3,70 @@
 module Github
   class Client < API
 
+    require_all 'github_api/client',
+      'activity',
+      'authorizations',
+      'emojis',
+      'gists',
+      'gitignore',
+      'git_data',
+      'issues',
+      'markdown',
+      'meta',
+      'orgs',
+      'pull_requests',
+      'repos',
+      'say',
+      'scopes',
+      'search',
+      'users'
+
     # Serving up the ‘social’ in Social Coding™, the Activity APIs
     # provide access to notifications, subscriptions, and timelines.
-    #
-    def activity(options={}, &block)
-      @activity ||= ApiFactory.new('Activity', current_options.merge(options), &block)
-    end
-
-    def emojis(options={}, &block)
-      @emojis ||= ApiFactory.new('Emojis', current_options.merge(options), &block)
-    end
-
-    def gists(options={}, &block)
-      @gists ||= ApiFactory.new('Gists', current_options.merge(options), &block)
-    end
-
-    def gitignore(options={}, &block)
-      @gitignore ||= ApiFactory.new('Gitignore', current_options.merge(options), &block)
-    end
+    namespace :activity
+
+    namespace :emojis
+
+    namespace :gists
+
+    namespace :gitignore
     alias :git_ignore :gitignore
 
     # 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={}, &block)
-      @git_data ||= ApiFactory.new('GitData', current_options.merge(options), &block)
-    end
+    namespace :git_data
     alias :git :git_data
 
-    def issues(options={}, &block)
-      @issues ||= ApiFactory.new('Issues', current_options.merge(options), &block)
-    end
+    namespace :issues
 
-    def markdown(options={}, &block)
-      @markdown ||= ApiFactory.new('Markdown', current_options.merge(options), &block)
-    end
+    namespace :markdown
 
-    def meta(options={}, &block)
-      @meta ||= ApiFactory.new('Meta', current_options.merge(options), &block)
-    end
+    namespace :meta
 
     # An API for users to manage their own tokens. You can only access your own
     # tokens, and only through Basic Authentication.
-    def oauth(options={}, &block)
-      @oauth ||= ApiFactory.new('Authorizations', current_options.merge(options), &block)
-    end
-    alias :authorizations :oauth
-
-    def orgs(options={}, &block)
-      @orgs ||= ApiFactory.new('Orgs', current_options.merge(options), &block)
-    end
+    namespace :authorizations
+    alias :oauth :authorizations
+
+    namespace :orgs
     alias :organizations :orgs
 
-    def pull_requests(options={}, &block)
-      @pull_requests ||= ApiFactory.new('PullRequests', current_options.merge(options), &block)
-    end
+    namespace :pull_requests
     alias :pulls :pull_requests
 
-    def repos(options={}, &block)
-      @repos ||= ApiFactory.new('Repos', current_options.merge(options), &block)
-    end
+    namespace :repos
     alias :repositories :repos
 
-    def octocat(options={}, &block)
-      @octocat ||= ApiFactory.new('Say', current_options.merge(options), &block)
-    end
+    namespace :say
+    alias :octocat :say
 
-    def scopes(options={}, &block)
-      @scopes ||= ApiFactory.new('Scopes', current_options.merge(options), &block)
-    end
+    namespace :scopes
 
-    def search(options={}, &block)
-      @search ||= ApiFactory.new('Search', current_options.merge(options), &block)
-    end
+    namespace :search
 
     # Many of the resources on the users API provide a shortcut for getting
     # information about the currently authenticated user.
-    #
-    def users(options={}, &block)
-      @users ||= ApiFactory.new('Users', current_options.merge(options), &block)
-    end
-
+    namespace :users
   end # Client
 end # Github

data/lib/github_api/client/activity.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Github
+  class Client::Activity < API
+
+    require_all 'github_api/client/activity',
+      'events',
+      'notifications',
+      'starring',
+      'watching'
+
+    # Access to Activity::Events API
+    namespace :events
+
+    # Access to Activity::Notifications API
+    namespace :notifications
+
+    # Access to Activity::Starring API
+    namespace :starring
+
+    # Access to Activity::Watching API
+    namespace :watching
+
+  end # Activity
+end # Github

data/lib/github_api/client/activity/events.rb

@@ -0,0 +1,216 @@
+# encoding: utf-8
+
+module Github
+  class Client::Activity::Events < API
+
+    # List all public events
+    #
+    # @example
+    #  github = Github.new
+    #  github.activity.events.public
+    #  github.activity.events.public { |event| ... }
+    #
+    # @api public
+    def public(*args)
+      arguments(args)
+
+      response = get_request("/events", arguments.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
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.repository 'user-name', 'repo-name'
+    #   github.activity.events.repository 'user-name', 'repo-name' { |event| ... }
+    #
+    # @example
+    #   github.activity.events.repository user: 'user-name', repo: 'repo-name'
+    #   github.activity.events.repository user: 'user-name', repo: 'repo-name' {|event| ... }
+    #
+    # @api public
+    def repository(*args)
+      arguments(args, required: [:user, :repo])
+
+      response = get_request("/repos/#{arguments.user}/#{arguments.repo}/events", arguments.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
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.issue 'user-name', 'repo-name'
+    #   github.activity.events.issue 'user-name', 'repo-name' { |event| ... }
+    #
+    # @example
+    #   github.activity.events.issue user: 'user-name', repo: 'repo-name'
+    #   github.activity.events.issue user: 'user-name', repo: 'repo-name' { |event| ... }
+    #
+    # @api public
+    def issue(*args)
+      arguments(args, required: [:user, :repo])
+
+      response = get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/events", arguments.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
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.network 'user-name', 'repo-name'
+    #   github.activity.events.network 'user-name', 'repo-name' { |event| ... }
+    #
+    # @example
+    #   github.activity.events.network user: 'user-name', repo: 'repo-name'
+    #   github.activity.events.network user: 'user-name', repo: 'repo-name' { |event| ... }
+    #
+    # @api public
+    def network(*args)
+      arguments(args, required: [:user, :repo])
+
+      response = get_request("/networks/#{arguments.user}/#{arguments.repo}/events", arguments.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
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.org 'org-name'
+    #   github.activity.events.org 'org-name' { |event| ... }
+    #
+    # @example
+    #   github.activity.events.org name: 'org-name'
+    #   github.activity.events.org name: 'org-name' { |event| ... }
+    #
+    # @api public
+    def org(*args)
+      arguments(args, required: [:name])
+
+      response = get_request("/orgs/#{arguments.name}/events", arguments.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.
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.received 'user-name'
+    #   github.activity.events.received 'user-name' { |event| ... }
+    #
+    # List all public events that a user has received
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.received 'user-name', public: true
+    #   github.activity.events.received 'user-name', public: true { |event| ... }
+    #
+    # @api public
+    def received(*args)
+      arguments(args, required: [:user])
+      params = arguments.params
+
+      public_events = if params['public']
+        params.delete('public')
+        '/public'
+      end
+
+      response = get_request("/users/#{arguments.user}/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.
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.performed 'user-name'
+    #   github.activity.events.performed 'user-name' { |event| ... }
+    #
+    # List all public events that a user has performed
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.performed 'user-name', public: true
+    #   github.activity.events.performed 'user-name', public: true { |event| ... }
+    #
+    # @api public
+    def performed(*args)
+      arguments(args, required: [:user])
+      params = arguments.params
+
+      public_events = if params['public']
+        params.delete('public')
+        '/public'
+      end
+
+      response = get_request("/users/#{arguments.user}/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.
+    #
+    # @example
+    #   github = Github.new
+    #   github.activity.events.user_org 'user-name', 'org-name'
+    #   github.activity.events.user_org 'user-name', 'org-name' { |event| ... }
+    #
+    # @example
+    #   github.activity.events.user_org user: 'user-name', name: 'org-name'
+    #   github.activity.events.user_org user: 'user-name', name: 'org-name' {|event| ...}
+    #
+    # @api public
+    def user_org(*args)
+      arguments(args, required: [:user, :name])
+
+      response = get_request("/users/#{arguments.user}/events/orgs/#{arguments.name}", arguments.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 # Client::Activity::Events
+end # Github

data/lib/github_api/client/activity/notifications.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+
+module Github
+  class Client::Activity::Notifications < API
+
+    # List your notifications
+    #
+    # List all notifications for the current user, grouped by repository.
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#list-your-notifications
+    #
+    # @param [Hash] params
+    # @option params [Boolean] :all
+    #   If true, show notifications marked as read.
+    #   Default: false
+    # @option params [Boolean] :participating
+    #   If true, only shows notifications in which the user
+    #   is directly participating or mentioned. Default: false
+    # @option params [String] :since
+    #   Filters out any notifications updated before the given time.
+    #   This is a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ.
+    #   Default: Time.now
+    #
+    # @example
+    #   github = Github.new oauth_token: 'token'
+    #   github.activity.notifications.list
+    #
+    # List your notifications in a repository
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#list-your-notifications-in-a-repository
+    #
+    # @example
+    #  github = Github.new
+    #  github.activity.notifications.list user: 'user-name', repo: 'repo-name'
+    #
+    # @api public
+    def list(*args)
+      arguments(args) do
+        permit %w[ all participating since user repo]
+      end
+      params = arguments.params
+
+      response = if ( (user_name = params.delete("user")) &&
+                      (repo_name = params.delete("repo")) )
+        get_request("/repos/#{user_name}/#{repo_name}/notifications", params)
+      else
+        get_request("/notifications", params)
+      end
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :all :list
+
+    # View a single thread
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#view-a-single-thread
+    #
+    # @example
+    #  github = Github.new oauth_token: 'token'
+    #  github.activity.notifications.get 'thread_id'
+    #  github.activity.notifications.get 'thread_id' { |thread| ... }
+    #
+    # @api public
+    def get(*args)
+      arguments(args, required: [:id])
+
+      response = get_request("/notifications/threads/#{arguments.id}", arguments.params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :find :get
+
+    # Mark as read
+    #
+    # Marking a notification as “read” removes it from the default view on GitHub.com.
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#mark-as-read
+    #
+    # @param [Hash] params
+    # @option params [String] :last_read_at
+    #   Describes the last point that notifications were checked.
+    #   Anything updated since this time will not be updated.
+    #   This is a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ.
+    #   Default: Time.now
+    #
+    # @example
+    #  github = Github.new oauth_token: 'token'
+    #  github.activity.notifications.mark
+    #
+    # Mark notifications as read in a repository
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#mark-notifications-as-read-in-a-repository
+    #
+    # @example
+    #  github.activity.notifications.mark user: 'user-name', repo: 'repo-name'
+    #
+    # Mark a thread as read
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#mark-a-thread-as-read
+    #
+    # @example
+    #  github.activity.notifications.mark id: 'thread-id'
+    #
+    # @api public
+    def mark(*args)
+      arguments(args) do
+        permit %w[ unread read last_read_at user repo id]
+      end
+      params = arguments.params
+
+      if ( (user_name = params.delete("user")) &&
+           (repo_name = params.delete("repo")) )
+
+        put_request("/repos/#{user_name}/#{repo_name}/notifications", params)
+      elsif (thread_id = params.delete("id"))
+        patch_request("/notifications/threads/#{thread_id}", params)
+      else
+        put_request("/notifications", params)
+      end
+    end
+
+    # Check to see if the current user is subscribed to a thread.
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#get-a-thread-subscription
+    #
+    # @example
+    #  github = Github.new oauth_token: 'token'
+    #  github.activity.notifications.subscribed? 'thread-id'
+    #
+    # @example
+    #   github.activity.notifications.subscribed? id: 'thread-id'
+    #
+    # @api public
+    def subscribed?(*args)
+      arguments(args, required: [:id])
+
+      get_request("/notifications/threads/#{arguments.id}/subscription", arguments.params)
+    end
+
+    # Create a thread subscription
+    #
+    # This lets you subscribe to a thread, or ignore it. Subscribing to a thread
+    # is unnecessary if the user is already subscribed to the repository. Ignoring
+    # a thread will mute all future notifications (until you comment or get
+    # @mentioned).
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#set-a-thread-subscription
+    #
+    # @param [Hash] params
+    # @option params [Boolean] :subscribed
+    #   Determines if notifications should be received from this thread
+    # @option params [Boolean] :ignored
+    #   Determines if all notifications should be blocked from this thread
+    #
+    # @example
+    #   github = Github.new oauth_token: 'token'
+    #   github.activity.notifications.create 'thread-id',
+    #     subscribed: true
+    #     ignored: false
+    #
+    # @api public
+    def create(*args)
+      arguments(args, required: [:id])
+
+      put_request("/notifications/threads/#{arguments.id}/subscription", arguments.params)
+    end
+
+    # Delete a thread subscription
+    #
+    # @see https://developer.github.com/v3/activity/notifications/#delete-a-thread-subscription
+    #
+    # @example
+    #   github = Github.new oauth_token: 'token'
+    #   github.activity.notifications.delete 'thread_id'
+    #
+    # @api public
+    def delete(*args)
+      arguments(args, required: [:id])
+
+      delete_request("/notifications/threads/#{arguments.id}/subscription", arguments.params)
+    end
+    alias :remove :delete
+  end # Client::Activity::Notifications
+end # Github