github_api 0.11.3 → 0.12.0

data/features/users/keys.feature

@@ -5,7 +5,7 @@ Feature: Accessing Users Keys API
   Should return the expected results depending on passed parameters
 
   Background:
-    Given I have "Github::Users::Keys" instance
+    Given I have "Github::Client::Users::Keys" instance
 
   Scenario: Lists all public keys for a user
 
@@ -25,3 +25,24 @@ Feature: Accessing Users Keys API
     Then the response status should be 200
       And the response type should be JSON
       And the response should be empty
+
+  Scenario: Create
+
+    Given I want to create resource with the following params:
+      | user   | repo            |
+      | murek  | github_api_test |
+    And I pass the following request options:
+      | title       | key                                              |
+      | Found a bug | ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC7ZihX0HkqN1m/m7Ae7xHJwewg8Nimpmsy6lgt32IphOh0JDx1ssiWTXUWP77Lj3VR6Y2oNbMguaf2sn+n4oTcojbJXuqj8zd16NqYOu7kJlCUIKpTgX+IvmO6XMZddd1Lq8LLIQMZRG7j3/6agDDWR6retmT4JOSCmbBEomoVP0NHPlL6XK5WlF05+6ssxbL9s8uD5q1QvlkjVuFSjWSdYM+IBgNFtw8kJwoKL+eadL4So/xTk+yBUAMUTPO+02mQ2VJ5R06mgSny3omalS3cym4KR4uwENABhk0drxG78rvpMNfjcvT9llRJ+FI8lVgQOI0729z+1ApiWgzEQsK3 |
+    When I make request within a cassette named "users/keys/create"
+    Then the response status should be 201
+      And the response type should be JSON
+      And the response should not be empty
+
+  Scenario: Delete
+    Given I want to delete resource with the following params:
+      | id      |
+      | 8715940 |
+    When I make request within a cassette named "users/keys/delete"
+    Then the response status should be 204
+      And the response should be empty

data/lib/github_api.rb

@@ -10,32 +10,48 @@ require 'github_api/core_ext/ordered_hash'
 require 'github_api/ext/faraday'
 
 module Github
-  extend Configuration
-
   LIBNAME = 'github_api'
 
   LIBDIR = File.expand_path("../#{LIBNAME}", __FILE__)
 
   class << self
+    def included(base)
+      base.extend ClassMethods
+    end
 
     # Alias for Github::Client.new
     #
+    # @param [Hash] options
+    #   the configuration options
+    #
     # @return [Github::Client]
+    #
+    # @api public
     def new(options = {}, &block)
       Github::Client.new(options, &block)
     end
 
     # Delegate to Github::Client
     #
-    def method_missing(method, *args, &block)
-      return super unless new.respond_to?(method)
-      new.send(method, *args, &block)
+    # @api private
+    def method_missing(method_name, *args, &block)
+      if new.respond_to?(method_name)
+        new.send(method_name, *args, &block)
+      elsif configuration.respond_to?(method_name)
+        Github.configuration.send(method_name, *args, &block)
+      else
+        super
+      end
     end
 
-    def respond_to?(method, include_private = false)
-      new.respond_to?(method, include_private) || super(method, include_private)
+    def respond_to?(method_name, include_private = false)
+      new.respond_to?(method_name, include_private) ||
+      configuration.respond_to?(method_name) ||
+      super(method_name, include_private)
     end
+  end
 
+  module ClassMethods
     # Requires internal github_api libraries
     #
     # @param [String] prefix
@@ -49,39 +65,28 @@ module Github
         require "#{File.join(prefix, lib)}"
       end
     end
+
+    # Main client global configuration
+    def configuration
+      @configuration ||= Github::Configuration.new
+    end
   end
 
+  extend ClassMethods
+
   require_all LIBDIR,
     'authorization',
     'validations',
     'normalizer',
     'parameter_filter',
     'api',
-    'arguments',
-    'activity',
-    'api_factory',
     'client',
-    'repos',
     'pagination',
     'request',
     'response',
     'response_wrapper',
     'error',
-    'issues',
-    'gists',
-    'git_data',
-    'gitignore',
-    'orgs',
-    'pull_requests',
-    'users',
-    'emojis',
-    'search',
-    'say',
-    'scopes',
-    'markdown',
-    'meta',
     'mime_type',
-    'authorizations',
     'page_links',
     'paged_request',
     'page_iterator',

data/lib/github_api/api.rb

@@ -1,28 +1,29 @@
 # encoding: utf-8
 
 require 'github_api/configuration'
-require 'github_api/connection'
-require 'github_api/request'
 require 'github_api/mime_type'
 require 'github_api/rate_limit'
 require 'github_api/core_ext/hash'
 require 'github_api/core_ext/array'
-require 'github_api/compatibility'
-require 'github_api/api/actions'
-require 'github_api/api_factory'
 require 'github_api/null_encoder'
 
+require 'github_api/request/verbs'
+
+require 'github_api/api/actions'
+require 'github_api/api/factory'
+require 'github_api/api/arguments'
+
 module Github
-  # Core class for api interface operations
+  # Core class responsible for api interface operations
   class API
+    extend Github::ClassMethods
     include Constants
     include Authorization
     include MimeType
-    include Connection
-    include Request
+    include Request::Verbs
     include RateLimit
 
-    attr_reader *Configuration.keys
+    attr_reader *Github.configuration.property_names
 
     attr_accessor *Validations::VALID_API_KEYS
 
@@ -30,7 +31,7 @@ module Github
 
     # Callback to update current configuration options
      class_eval do
-       Configuration.keys.each do |key|
+       Github.configuration.property_names.each do |key|
          define_method "#{key}=" do |arg|
            self.instance_variable_set("@#{key}", arg)
            self.current_options.merge!({:"#{key}" => arg})
@@ -40,6 +41,7 @@ module Github
 
     # Create new API
     #
+    # @api public
     def initialize(options={}, &block)
       setup(options)
       yield_or_eval(&block) if block_given?
@@ -52,10 +54,11 @@ module Github
 
     # Configure options and process basic authorization
     #
+    # @api private
     def setup(options={})
-      options = Github.options.merge(options)
+      options = Github.configuration.fetch.merge(options)
       self.current_options = options
-      Configuration.keys.each do |key|
+      Github.configuration.property_names.each do |key|
         send("#{key}=", options[key])
       end
       process_basic_auth(options[:basic_auth])
@@ -73,13 +76,165 @@ module Github
       end
     end
 
+    # List of before callbacks
+    #
+    # @api public
+    def self.before_callbacks
+      @before_callbacks ||= []
+    end
+
+    # List of after callbacks
+    #
+    # @api public
+    def self.after_callbacks
+      @after_callbacks ||= []
+    end
+
+    # Before request filter
+    #
+    # @api public
+    def self.before_request(callback, params = {})
+      before_callbacks << params.merge(callback: callback)
+    end
+
+    # After request filter
+    #
+    # @api public
+    def self.after_request(callback, params = {})
+      after_callbacks << params.merge(callback: callback)
+    end
+
+    class << self
+      attr_reader :root
+      alias_method :root?, :root
+    end
+
+    def self.root!
+      @root = true
+    end
+
+    def self.inherited(child_class)
+      before_callbacks.reverse_each { |callback|
+        child_class.before_callbacks.unshift(callback)
+      }
+      after_callbacks.reverse_each { |callback|
+        child_class.after_callbacks.unshift(callback)
+      }
+      extend_with_actions(child_class)
+      unless child_class.instance_variable_defined?(:@root)
+        child_class.instance_variable_set(:@root, false)
+      end
+      super
+    end
+
+    root!
+
+    def self.internal_methods
+      api = self
+      api = api.superclass until api.root?
+      api.public_instance_methods(true)
+    end
+
+    def self.extra_methods
+      ['actions']
+    end
+
+    # Find all the api methods that should be considred by
+    # request callbacks.
+    #
+    # @return [Set]
+    #
+    # @api private
+    def self.request_methods
+      @request_methods ||= begin
+        methods = (public_instance_methods(true) -
+                   internal_methods +
+                   public_instance_methods(false)).uniq.map(&:to_s)
+        Set.new(methods - extra_methods)
+      end
+    end
+
+    def self.clear_request_methods!
+      @request_methods = nil
+    end
+
+    def self.method_added(method_name)
+      method_name = method_name.to_s.gsub(/_with(out)?_callback_.*$/, '')
+      # Only subclasses matter
+      return if self.root?
+      return if extra_methods.include?(method_name)
+      # Only public methods are of interest
+      return unless request_methods.include?(method_name)
+      # Do not redefine
+      return if (@__methods_added ||= []).include?(method_name)
+
+      class_name     = self.name.to_s.split('::').last.downcase
+      with_method    = "#{method_name}_with_callback_#{class_name}"
+      without_method = "#{method_name}_without_callback_#{class_name}"
+
+      return if public_method_defined?(with_method)
+
+      [method_name, with_method, without_method].each do |met|
+        @__methods_added << met
+      end
+      return if public_method_defined?(with_method)
+
+      define_method(with_method) do |*args, &block|
+        send(:execute, without_method, *args, &block)
+      end
+      alias_method without_method, method_name
+      alias_method method_name, with_method
+      clear_request_methods!
+    end
+
+    # Filter callbacks based on kind
+    #
+    # @param [Symbol] kind
+    #   one of :before or :after
+    #
+    # @return [Array[Hash]]
+    #
+    # @api private
+    def filter_callbacks(kind, action_name)
+      matched_callbacks = self.class.send("#{kind}_callbacks").select do |callback|
+        callback[:only].nil? || callback[:only].include?(action_name)
+      end
+    end
+
+    # Run all callbacks associated with this action
+    #
+    # @apram [Symbol] action_name
+    #
+    # @api private
+    def run_callbacks(action_name, &block)
+      filter_callbacks(:before, action_name).each { |hook| send hook[:callback] }
+      yield if block_given?
+      filter_callbacks(:after, action_name).each { |hook| send hook[:callback] }
+    end
+
+    # Execute action
+    #
+    # @param [Symbol] action
+    #
+    # @api private
+    def execute(action, *args, &block)
+      action_name = action.to_s.gsub(/_with(out)?_callback_.*$/, '')
+      result = nil
+      run_callbacks(action_name) do
+        result = send(action, *args, &block)
+      end
+      result
+    end
+
     # Responds to attribute query or attribute clear
-    def method_missing(method, *args, &block) # :nodoc:
-      case method.to_s
+    #
+    # @api private
+    def method_missing(method_name, *args, &block) # :nodoc:
+      case method_name.to_s
       when /^(.*)\?$/
-        return !!self.send($1.to_s)
+        return !!send($1.to_s)
       when /^clear_(.*)$/
-        self.send("#{$1.to_s}=", nil)
+        send("#{$1.to_s}=", nil)
       else
         super
       end
@@ -93,7 +248,7 @@ module Github
       if not_set
         @arguments
       else
-        @arguments = Arguments.new(self, options).parse(*args, &block)
+        @arguments = Arguments.new(options.merge!(api: self)).parse(*args, &block)
       end
     end
 
@@ -111,7 +266,15 @@ module Github
       end
     end
 
-    # Set an option to a given value
+    # Set a configuration option for a given namespace
+    #
+    # @param [String] option
+    # @param [Object] value
+    # @param [Boolean] ignore_setter
+    #
+    # @return [self]
+    #
+    # @api public
     def set(option, value=(not_set=true), ignore_setter=false, &block)
       raise ArgumentError, 'value not set' if block and !not_set
       return self if !not_set and value.nil?
@@ -129,10 +292,52 @@ module Github
       self
     end
 
+    # Defines a namespace
+    #
+    # @param [Array[Symbol]] names
+    #   the name for the scope
+    #
+    # @return [self]
+    #
+    # @api public
+    def self.namespace(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      names   = names.map(&:to_sym)
+      name    = names.pop
+      return if public_method_defined?(name)
+
+      class_name = extract_class_name(name, options)
+      define_method(name) do |*args, &block|
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        API::Factory.new(class_name, current_options.merge(options), &block)
+      end
+      self
+    end
+
+    # Extracts class name from options
+    #
+    # @param [Hash] options
+    # @option options [String] :full_name
+    #   the full name for the class
+    # @option options [Boolean] :root
+    #   if the class is at the root or not
+    #
+    # @return [String]
+    #
+    # @api private
+    def self.extract_class_name(name, options)
+      converted  = options.fetch(:full_name, name).to_s
+      converted  = converted.split('_').map(&:capitalize).join
+      class_name = options.fetch(:root, false) ? '': "#{self.name}::"
+      class_name += converted
+      class_name
+    end
+
     private
 
     # Set multiple options
     #
+    # @api private
     def set_options(options)
       unless options.respond_to?(:each)
         raise ArgumentError, 'cannot iterate over value'
@@ -140,6 +345,9 @@ module Github
       options.each { |key, value| set(key, value) }
     end
 
+    # Define setters and getters
+    #
+    # @api private
     def define_accessors(option, value)
       setter = proc { |val|  set option, val, true }
       getter = proc { value }
@@ -150,6 +358,7 @@ module Github
 
     # Dynamically define a method for setting request option
     #
+    # @api private
     def define_singleton_method(method_name, content=Proc.new)
       (class << self; self; end).class_eval do
         undef_method(method_name) if method_defined?(method_name)
@@ -160,11 +369,5 @@ module Github
         end
       end
     end
-
-    def _merge_mime_type(resource, params) # :nodoc:
-#       params['resource'] = resource
-#       params['mime_type'] = params['mime_type'] || :raw
-    end
-
   end # API
 end # Github