github_api 0.9.0 → 0.9.1

data/lib/github_api/activity/watching.rb

@@ -12,12 +12,10 @@ module Github
     #  github.activity.watching.list
     #  github.activity.watching.list { |watcher| ... }
     #
-    def list(user_name, repo_name, params={})
-      set :user => user_name, :repo => repo_name
-      assert_presence_of user, repo
-      normalize! params
+    def list(*args)
+      arguments(args, :required => [:user, :repo])
 
-      response = get_request("/repos/#{user}/#{repo}/subscribers", params)
+      response = get_request("/repos/#{user}/#{repo}/subscribers", arguments.params)
       return response unless block_given?
       response.each { |el| yield el }
     end
@@ -36,8 +34,7 @@ module Github
     #  github.activity.watching.watched
     #
     def watched(*args)
-      params = args.extract_options!
-      normalize! params
+      params = arguments(args).params
 
       response = if (user_name = params.delete('user'))
         get_request("/users/#{user_name}/subscriptions", params)
@@ -55,10 +52,10 @@ module Github
     #  github = Github.new
     #  github.activity.watching.watching? 'user-name', 'repo-name'
     #
-    def watching?(user_name, repo_name, params={})
-      assert_presence_of user_name, repo_name
-      normalize! params
-      get_request("/user/subscriptions/#{user_name}/#{repo_name}", params)
+    def watching?(*args)
+      arguments(args, :required => [:user, :repo])
+
+      get_request("/user/subscriptions/#{user}/#{repo}", arguments.params)
       true
     rescue Github::Error::NotFound
       false
@@ -72,10 +69,10 @@ module Github
     #  github = Github.new
     #  github.activity.watching.watch 'user-name', 'repo-name'
     #
-    def watch(user_name, repo_name, params={})
-      assert_presence_of user_name, repo_name
-      normalize! params
-      put_request("/user/subscriptions/#{user_name}/#{repo_name}", params)
+    def watch(*args)
+      arguments(args, :required => [:user, :repo])
+
+      put_request("/user/subscriptions/#{user}/#{repo}", arguments.params)
     end
 
     # Stop watching a repository
@@ -85,10 +82,10 @@ module Github
     #  github = Github.new
     #  github.activity.watching.unwatch 'user-name', 'repo-name'
     #
-    def unwatch(user_name, repo_name, params={})
-      assert_presence_of user_name, repo_name
-      normalize! params
-      delete_request("/user/subscriptions/#{user_name}/#{repo_name}", params)
+    def unwatch(*args)
+      arguments(args, :required => [:user, :repo])
+
+      delete_request("/user/subscriptions/#{user}/#{repo}", arguments.params)
     end
 
   end # Activity::Watching

data/lib/github_api/api.rb

@@ -2,7 +2,6 @@
 
 require 'github_api/configuration'
 require 'github_api/connection'
-require 'github_api/validations'
 require 'github_api/request'
 require 'github_api/mime_type'
 require 'github_api/rate_limit'
@@ -21,16 +20,10 @@ module Github
     include Connection
     include Request
     include RateLimit
-    # include Configuration
-
-    # TODO consider these optional in a stack
-    include Validations
-    include ParameterFilter
-    include Normalizer
 
     attr_reader *Configuration.keys
 
-    attr_accessor *VALID_API_KEYS
+    attr_accessor *Validations::VALID_API_KEYS
 
     attr_accessor :current_options
 
@@ -92,9 +85,36 @@ module Github
       end
     end
 
+    # Acts as setter and getter for api requests arguments parsing.
+    #
+    # Returns Arguments instance.
+    #
+    def arguments(args=(not_set = true), options={}, &block)
+      if not_set
+        @arguments
+      else
+        @arguments = Arguments.new(self, options).parse(*args, &block)
+      end
+    end
+
+    # Scope for passing request required arguments.
+    #
+    def with(args)
+      case args
+      when Hash
+        set args
+      when /.*\/.*/i
+        user, repo = args.split('/')
+        set :user => user, :repo => repo
+      else
+        ::Kernel.raise ArgumentError, 'This api does not support passed in arguments'
+      end
+    end
+
     # Set an option to a given value
     def set(option, value=(not_set = true), &block)
       raise ArgumentError, 'value not set' if block and !not_set
+      return self if !not_set and value.nil?
 
       if not_set
         set_options option
@@ -105,12 +125,14 @@ module Github
         return __send__("#{option}=", value)
       end
 
+      define_accessors option, value
       self
     end
 
     private
 
     # Set multiple options
+    #
     def set_options(options)
       unless options.respond_to?(:each)
         raise ArgumentError, 'cannot iterate over value'
@@ -118,6 +140,27 @@ module Github
       options.each { |key, value| set(key, value) }
     end
 
+    def define_accessors(option, value)
+      setter = proc { |val| set option, value }
+      getter = proc { value }
+
+      define_singleton_method("#{option}=", setter) if setter
+      define_singleton_method(option, getter) if getter
+    end
+
+    # Dynamically define a method for setting request option
+    #
+    def define_singleton_method(name, content=Proc.new)
+      (class << self; self; end).class_eval do
+        undef_method(name) if method_defined? name
+        if String === content
+          class_eval("def #{name}() #{content}; end")
+        else
+          define_method(name, &content)
+        end
+      end
+    end
+
     def _merge_mime_type(resource, params) # :nodoc:
 #       params['resource'] = resource
 #       params['mime_type'] = params['mime_type'] || :raw

data/lib/github_api/arguments.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+
+module Github
+  # Request arguments handler
+  class Arguments
+
+    include Normalizer
+    include ParameterFilter
+    include Validations
+
+    # Parameters passed to request
+    attr_reader :params
+
+    attr_reader :remaining
+
+    # The request api
+    #
+    attr_reader :api
+
+    # Required arguments
+    #
+    attr_reader :required
+    private :required
+
+    # Optional arguments
+    #
+    attr_reader :optional
+    private :optional
+
+    # Takes api, filters and required arguments
+    #
+    # = Parameters
+    #  :required - arguments that must be present before request is fired
+    #
+    def initialize(api, options={})
+      normalize! options
+      @api      = api
+      @required = options.fetch('required', []).map(&:to_s)
+      @optional = options.fetch('optional', []).map(&:to_s)
+    end
+
+    # Parse arguments to allow for flexible api calls.
+    # Arguments can be part of parameters hash or be simple string arguments.
+    #
+    def parse(*args, &block)
+      options = args.extract_options!
+      normalize! options
+
+      if !args.size.zero?
+        parse_arguments *args
+      else
+        # Arguments are inside the parameters hash
+        parse_options options
+      end
+      @params = options
+      @remaining = extract_remaining(args)
+      yield_or_eval(&block)
+      self
+    end
+
+    # Remove unkown keys from parameters hash.
+    #
+    # = Parameters
+    #  :recursive - boolean that toggles whether nested filtering should be applied
+    #
+    def sift(keys, key=nil, options={})
+      filter! keys, (key.nil? ? params : params[key]), options if keys.any?
+      self
+    end
+
+    # Check if required keys are present inside parameters hash.
+    #
+    def assert_required(required)
+      assert_required_keys required, params
+      self
+    end
+
+    # Check if parameters match expected values.
+    #
+    def assert_values(values, key=nil)
+      assert_valid_values values, (key.nil? ? params : params[key])
+      self
+    end
+
+    private
+
+    # Check and set all requried arguments.
+    #
+    def parse_arguments(*args)
+      assert_presence_of *args
+      required.each_with_index do |req, indx|
+        api.set req, args[indx]
+      end
+      check_requirement!(*args)
+    end
+
+    # Find remaining arguments
+    #
+    def extract_remaining(args)
+      args[required.size..-1]
+    end
+
+    # Remove required arguments from parameters and
+    # validate their presence(if not nil or empty string).
+    #
+    def parse_options(options)
+      options.each { |key, val| remove_required(options, key, val) }
+      provided_args = check_assignment!(options)
+      check_requirement!(*provided_args.keys)
+    end
+
+    # Remove required argument from parameters
+    #
+    def remove_required(options, key, val)
+      key = key.to_s
+      if required.include? key
+        assert_presence_of val
+        options.delete key
+        api.set key, val
+      end
+    end
+
+    # Check if required arguments have been set on instance.
+    #
+    def check_assignment!(options)
+      result = required.inject({}) { |hash, arg|
+        if api.respond_to?(:"#{arg}") && (value = api.send(:"#{arg}"))
+          hash[arg] = value
+        end
+        hash
+      }
+      assert_presence_of result
+      result
+    end
+
+    # Check if required arguments are present.
+    #
+    def check_requirement!(*args)
+      args_length     = args.length
+      required_length = required.length
+
+      if args_length < required_length
+        ::Kernel.raise ArgumentError, "wrong number of arguments (#{args_length} for #{required_length})"
+      end
+    end
+
+    # Evaluate block
+    #
+    def yield_or_eval(&block)
+      return unless block
+      block.arity > 0 ? yield(self) : self.instance_eval(&block)
+    end
+
+  end # Arguments
+end # Github

data/lib/github_api/authorizations.rb

@@ -20,11 +20,11 @@ module Github
     #  github.oauth.list
     #  github.oauth.list { |auth| ... }
     #
-    def list(params={})
+    def list(*args)
       _check_if_authenticated
-      normalize! params
+      arguments(args)
 
-      response = get_request("/authorizations", params)
+      response = get_request("/authorizations", arguments.params)
       return response unless block_given?
       response.each { |el| yield el }
     end
@@ -36,12 +36,11 @@ module Github
     #  github = Github.new :basic_auth => 'login:password'
     #  github.oauth.get 'authorization-id'
     #
-    def get(authorization_id, params={})
-      assert_presence_of(authorization_id)
+    def get(*args)
       _check_if_authenticated
-      normalize! params
+      arguments(args, :required => [:authorization_id])
 
-      get_request("/authorizations/#{authorization_id}", params)
+      get_request("/authorizations/#{authorization_id}", arguments.params)
     end
     alias :find :get
 
@@ -57,12 +56,13 @@ module Github
     #  github.oauth.create
     #    "scopes" => ["public_repo"]
     #
-    def create(params={})
+    def create(*args)
       _check_if_authenticated
-      normalize! params
-      filter! VALID_AUTH_PARAM_NAMES, params
+      arguments(args) do
+        sift VALID_AUTH_PARAM_NAMES
+      end
 
-      post_request("/authorizations", params)
+      post_request("/authorizations", arguments.params)
     end
 
     # Update an existing authorization
@@ -78,13 +78,13 @@ module Github
     #  github = Github.new :basic_auth => 'login:password'
     #  github.oauth.update "authorization-id", "add_scopes" => ["repo"],
     #
-    def update(authorization_id, params={})
+    def update(*args)
       _check_if_authenticated
-      assert_presence_of authorization_id
-      normalize! params
-      filter! VALID_AUTH_PARAM_NAMES, params
+      arguments(args, :required => [:authorization_id]) do
+        sift VALID_AUTH_PARAM_NAMES
+      end
 
-      patch_request("/authorizations/#{authorization_id}", params)
+      patch_request("/authorizations/#{authorization_id}", arguments.params)
     end
     alias :edit :update
 
@@ -93,12 +93,11 @@ module Github
     # = Examples
     #  github.oauth.delete 'authorization-id'
     #
-    def delete(authorization_id, params={})
+    def delete(*args)
       _check_if_authenticated
-      assert_presence_of authorization_id
-      normalize! params
+      arguments(args, :required => [:authorization_id])
 
-      delete_request("/authorizations/#{authorization_id}", params)
+      delete_request("/authorizations/#{authorization_id}", arguments.params)
     end
     alias :remove :delete
 

data/lib/github_api/configuration.rb

@@ -16,6 +16,7 @@ module Github
       :connection_options,
       :repo,
       :user,
+      :org,
       :login,
       :password,
       :basic_auth
@@ -66,6 +67,9 @@ module Github
     # By default, don't set repository name
     DEFAULT_REPO = nil
 
+    # By default, don't set organization name
+    DEFAULT_ORG = nil
+
     attr_accessor *VALID_OPTIONS_KEYS
 
     # Convenience method to allow for global setting of configuration options
@@ -104,6 +108,7 @@ module Github
       self.mime_type          = DEFAULT_MIME_TYPE
       self.user               = DEFAULT_USER
       self.repo               = DEFAULT_REPO
+      self.org                = DEFAULT_ORG
       self.login              = DEFAULT_LOGIN
       self.password           = DEFAULT_PASSWORD
       self.basic_auth         = DEFAULT_BASIC_AUTH

data/lib/github_api/emojis.rb

@@ -10,10 +10,10 @@ module Github
     #
     #  Github.emojis.list
     #
-    def list(params={})
-      normalize! params
+    def list(*args)
+      arguments(args)
 
-      get_request("/emojis", params)
+      get_request("/emojis", arguments.params)
     end
 
   end # Emojis