github_api 0.4.3 → 0.4.4

data/lib/github_api/filter.rb

@@ -0,0 +1,56 @@
+module Github
+  module Filter
+
+    def process_params(*args)
+      yield self if block_given?
+    end
+
+    def normalize(params)
+      _normalize_params_keys params
+    end
+
+    def filter(keys, params)
+      _filter_params_keys(keys, params)
+    end
+
+    # Turns any keys from nested hashes including nested arrays into strings
+    def _normalize_params_keys(params)  #  :nodoc:
+      case params
+      when Hash
+        params.keys.each do |k|
+          params[k.to_s] = params.delete(k)
+          _normalize_params_keys(params[k.to_s])
+        end
+      when Array
+        params.map! do |el|
+          _normalize_params_keys(el)
+        end
+      else
+        params.to_s
+      end
+      return params
+    end
+
+    # Removes any keys from nested hashes that don't match predefiend keys
+    def _filter_params_keys(keys, params, options={:recursive => true})  # :nodoc:
+      case params
+      when Hash
+        params.keys.each do |k, v|
+          unless (keys.include?(k) or Github::Validation::VALID_API_KEYS.include?(k))
+            params.delete(k)
+          else
+            _filter_params_keys(keys, params[k]) if options[:recursive]
+          end
+        end
+      when Array
+        params.map! do |el|
+          _filter_params_keys(keys, el) if options[:recursive]
+        end
+      else
+        params
+      end
+      return params
+    end
+
+  end # Filter
+end # Github

data/lib/github_api/gists.rb

@@ -36,7 +36,9 @@ module Github
     #
     def gists(user_name=nil, params={})
       _update_user_repo_params(user_name)
-      _normalize_params_keys(params)
+      process_params do
+        normalize params
+      end
 
       response = if user
         get("/users/#{user}/gists", params)
@@ -57,7 +59,9 @@ module Github
     #  @github.gists.starred
     #
     def starred(params={})
-      _normalize_params_keys(params)
+      process_params do
+        normalize params
+      end
 
       response = get("/gists/starred", params)
       return response unless block_given?

data/lib/github_api/gists/comments.rb

@@ -4,7 +4,11 @@ module Github
   class Gists
     module Comments
 
-      REQUIRED_GIST_COMMENT_INPUTS = %w[ 
+      REQUIRED_GIST_COMMENT_INPUTS = %w[
+        body
+      ].freeze
+
+      ALLOWED_GIST_COMMENT_INPUTS = %w[
         body
         mime_type
         resource
@@ -14,72 +18,89 @@ module Github
       #
       # = Examples
       #  @github = Github.new
-      #  @github.gists.gist_comments 'gist-id'
+      #  @github.gists.comments 'gist-id'
       #
-      def gist_comments(gist_id, params={})
+      def comments(gist_id, params={})
         _normalize_params_keys(params)
+        _validate_presence_of(gist_id)
         _merge_mime_type(:gist_comment, params)
 
-        get("/gists/#{gist_id}/comments", params)
+        response = get("/gists/#{gist_id}/comments", params)
+        return response unless block_given?
+        response.each { |el| yield el }
       end
+      alias :list_comments :comments
+      alias :gist_comments :comments
 
       # Get a single comment
       #
       # = Examples
       #  @github = Github.new
-      #  @github.gists.gist_comment 'comment-id'
+      #  @github.gists.comment 'comment-id'
       #
-      def gist_comment(comment_id, params={})
+      def comment(comment_id, params={})
         _normalize_params_keys(params)
+        _validate_presence_of(comment_id)
         _merge_mime_type(:gist_comment, params)
 
         get("/gists/comments/#{comment_id}", params)
       end
+      alias :gist_comment :comment
+      alias :get_comment  :comment
 
       # Create a comment
       #
       # = Examples
       #  @github = Github.new
-      #  @github.gists.create_gist_comment 'gist-id'
+      #  @github.gists.create_comment 'gist-id'
       #
-      def create_gist_comment(gist_id, params={})
+      def create_comment(gist_id, params={})
         _normalize_params_keys(params)
         _merge_mime_type(:gist_comment, params)
-        _filter_params_keys(REQUIRED_GIST_COMMENT_INPUTS, params)
+        _filter_params_keys(ALLOWED_GIST_COMMENT_INPUTS, params)
 
-        raise ArgumentError, "Required inputs are: :body" unless _validate_inputs(REQUIRED_GIST_COMMENT_INPUTS, params)
+        unless _validate_inputs(REQUIRED_GIST_COMMENT_INPUTS, params)
+          raise ArgumentError, "Required inputs are: :body"
+        end
 
         post("/gists/#{gist_id}/comments", params)
       end
+      alias :create_gist_comment :create_comment
 
       # Edit a comment
       #
       # = Examples
       #  @github = Github.new
-      #  @github.gists.edit_gist_comment 'comment-id'
+      #  @github.gists.edit_comment 'comment-id'
       #
-      def edit_gist_comment(comment_id, params={})
+      def edit_comment(comment_id, params={})
         _normalize_params_keys(params)
+        _validate_presence_of(comment_id)
         _merge_mime_type(:gist_comment, params)
-        _filter_params_keys(REQUIRED_GIST_COMMENT_INPUTS, params)
+        _filter_params_keys(ALLOWED_GIST_COMMENT_INPUTS, params)
 
-        raise ArgumentError, "Required inputs are: :body" unless _validate_inputs(REQUIRED_GIST_COMMENT_INPUTS, params)
+        unless _validate_inputs(REQUIRED_GIST_COMMENT_INPUTS, params)
+          raise ArgumentError, "Required inputs are: :body"
+        end
 
         patch("/gists/comments/#{comment_id}", params)
       end
+      alias :edit_gist_comment :edit_comment
 
       # Delete a comment
       #
       # = Examples
       #  @github = Github.new
-      #  @github.gists.delete_gist_comment 'comment-id'
+      #  @github.gists.delete_comment 'comment-id'
       #
-      def delete_gist_comment(comment_id, params={})
+      def delete_comment(comment_id, params={})
         _normalize_params_keys(params)
+        _validate_presence_of(comment_id)
         _merge_mime_type(:gist_comment, params)
 
         delete("/gists/comments/#{comment_id}", params)
       end
+      alias :delete_gist_comment :delete_comment
 
     end # Comments
   end # Gists

data/lib/github_api/ratelimit_status.rb

@@ -0,0 +1,17 @@
+module Github
+  class RatelimitStatus
+    include Github::Constants
+
+    attr_reader :ratelimit_limit, :ratelimit_remaining
+
+    def initialize(env)
+      @env = env
+      @ratelimit_limit     = env[:response_headers][RATELIMIT_LIMIT]
+      @ratelimit_remaining = env[:response_headers][RATELIMIT_REMAINING]
+    end
+
+    def ratelimit_reset_time
+      @ratelimit_reset_time ||= Time.parse(@env[:reponse_headers]['date'])
+    end
+  end
+end

data/lib/github_api/repos/hooks.rb

@@ -96,9 +96,11 @@ module Github
         _validate_user_repo_params(user, repo) unless user? && repo?
 
         _normalize_params_keys(params)
-        _filter_params_keys(VALID_HOOK_PARAM_NAMES, params)
+        _filter_params_keys(VALID_HOOK_PARAM_NAMES, params, :recursive => false)
 
-        raise ArgumentError, "Required parameters are: name, config" unless _validate_inputs(REQUIRED_PARAMS, params)
+        unless _validate_inputs(REQUIRED_PARAMS, params)
+          raise ArgumentError, "Required parameters are: name, config"
+        end
 
         post("/repos/#{user}/#{repo}/hooks", params)
       end
@@ -130,9 +132,11 @@ module Github
         _validate_presence_of hook_id
 
         _normalize_params_keys(params)
-        _filter_params_keys(VALID_HOOK_PARAM_NAMES, params)
+        _filter_params_keys(VALID_HOOK_PARAM_NAMES, params, :recursive => false)
 
-        raise ArgumentError, "Required parameters are: name, config" unless _validate_inputs(REQUIRED_PARAMS, params)
+        unless _validate_inputs(REQUIRED_PARAMS, params)
+          raise ArgumentError, "Required parameters are: name, config"
+        end
 
         patch("/repos/#{user}/#{repo}/hooks/#{hook_id}", params)
       end

data/lib/github_api/result.rb

@@ -27,6 +27,10 @@ module Github
       loaded? ? @env[:response_headers][ETAG] : nil
     end
 
+    def date
+      loaded? ? @env[:response_headers][DATE] : nil
+    end
+
     def server
       loaded? ? @env[:response_headers][SERVER] : nil
     end

data/lib/github_api/validation.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Github
+  module Validation
+
+    VALID_API_KEYS = [
+      'page',
+      'per_page',
+      'jsonp_callback'
+    ]
+
+    # Ensures that esential input parameters are present before request is made
+    #
+    def _validate_inputs(required, provided)
+      required.all? do |key|
+        provided.has_deep_key? key
+      end
+    end
+
+    # Ensures that esential arguments are present before request is made
+    #
+    def _validate_presence_of(*params)
+      params.each do |param|
+        raise ArgumentError, "parameter cannot be nil" if param.nil?
+      end
+    end
+
+    # Check if user or repository parameters are passed
+    #
+    def _validate_user_repo_params(user_name, repo_name)
+      raise ArgumentError, "[user] parameter cannot be nil" if user_name.nil?
+      raise ArgumentError, "[repo] parameter cannot be nil" if repo_name.nil?
+    end
+
+    # Ensures that hash values contain predefined values
+    #
+    def _validate_params_values(permitted, params)
+      params.each do |k, v|
+        next unless permitted.keys.include?(k)
+        if permitted[k].is_a?(Array) && !permitted[k].include?(params[k])
+          raise ArgumentError, "Wrong value for #{k}, allowed: #{permitted[k].join(', ')}"
+        elsif permitted[k].is_a?(Regexp) && !(permitted[k] =~ params[k])
+          raise ArgumentError, "String does not match the parameter value."
+        end
+      end
+    end
+
+  end # Validation
+end # Github

data/lib/github_api/version.rb

@@ -4,7 +4,7 @@ module Github
   module VERSION
     MAJOR = 0
     MINOR = 4
-    PATCH = 3
+    PATCH = 4
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.');

data/spec/fixtures/gists/comment.json

@@ -0,0 +1,13 @@
+{
+  "id": 1,
+  "url": "https://api.github.com/gists/comments/1",
+  "body": "Just commenting for the sake of commenting",
+  "user": {
+    "login": "octocat",
+    "id": 1,
+    "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+    "gravatar_id": "somehexcode",
+   "url": "https://api.github.com/users/octocat"
+  },
+ "created_at": "2011-04-18T23:23:56Z"
+}

data/spec/fixtures/gists/comments.json

@@ -0,0 +1,15 @@
+[
+  {
+    "id": 1,
+    "url": "https://api.github.com/gists/comments/1",
+    "body": "Just commenting for the sake of commenting",
+    "user": {
+      "login": "octocat",
+      "id": 1,
+      "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+      "gravatar_id": "somehexcode",
+     "url": "https://api.github.com/users/octocat"
+    },
+   "created_at": "2011-04-18T23:23:56Z"
+  }
+]

data/spec/github/api_factory_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Github::ApiFactory, :type => :base do
+
+  context '#new' do
+    it 'throws error if klass type is ommitted' do
+      expect { described_class.new nil }.to raise_error(ArgumentError)
+    end
+
+    it 'instantiates a new object' do
+      described_class.new('Repos').should be_a Github::Repos
+    end
+  end
+end # Github::ApiFactory

data/spec/github/filter_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'github_api/core_ext/hash'
+
+describe Github::Filter, :type => :base do
+
+  let(:repos_instance) { Github::Repos.new }
+  let(:block) {
+    Proc.new do |repo|
+      repo = repos_instance
+    end
+  }
+  let(:hash) {  { :a => { :b => { :c => 1 } } }  }
+
+  context '#process_params' do
+
+    it 'correctly yields current api instance' do
+      github.repos.should_receive(:process_params).and_yield repos_instance
+      github.repos.process_params(&block).should eq repos_instance
+    end
+  end
+
+  context '#normalize' do
+    it 'should call normalize on passed block' do
+      github.repos.process_params(&block).should respond_to :normalize
+    end
+
+    it 'should normalize params inside block' do
+      github.repos.stub(:process_params).and_yield repos_instance
+      github.repos.process_params do |repo|
+        repo.normalize hash
+      end
+      hash.all_keys.should include 'a'
+      hash.all_keys.should_not include :a
+    end
+  end
+
+  context '#filter' do
+    it 'should call filter on passed block' do
+      github.repos.process_params(&block).should respond_to :filter
+    end
+
+    it 'should filter params inside block' do
+      github.repos.stub(:process_params).and_yield repos_instance
+      github.repos.process_params do |repo|
+        repo.filter [:a], hash
+      end
+      hash.all_keys.should     include :a
+      hash.all_keys.should_not include :b
+    end
+  end
+
+  context '#_normalize_params_keys' do
+    it 'converts hash keys to string' do
+      ['a', 'b', 'c'].each do |key|
+        github.repos._normalize_params_keys(hash).all_keys.should include key
+      end
+      [:a, :b, :c].each do |key|
+        github.repos._normalize_params_keys(hash).all_keys.should_not include key
+      end
+    end
+  end
+
+  context '#_filter_params_keys' do
+    it 'removes unwanted keys from hash' do
+      github.repos._filter_params_keys([:a], hash)
+      hash.all_keys.should     include :a
+      hash.all_keys.should_not include :b
+      hash.all_keys.should_not include :c
+    end
+
+    it 'recursively filters inputs tree' do
+      github.repos._filter_params_keys([:a, :b], hash)
+      hash.all_keys.should_not include :c
+    end
+
+    it 'filters inputs tree only on top level' do
+      github.repos._filter_params_keys([:a, :b], hash, :recursive => false)
+      hash.all_keys.should include :c
+    end
+  end
+
+end # Github::Filter

data/spec/github/gists/comments_spec.rb

@@ -1,5 +1,257 @@
 require 'spec_helper'
 
 describe Github::Gists::Comments, :type => :base do
-  pending
+
+  let(:gist_id)    { '1' }
+  let(:comment_id) { 1 }
+
+  describe "#comments" do
+    context 'check aliases' do
+      it { github.gists.should respond_to :comments }
+      it { github.gists.should respond_to :list_comments }
+    end
+
+    context 'resource found' do
+      before do
+        stub_get("/gists/#{gist_id}/comments").
+          to_return(:body => fixture('gists/comments.json'),
+            :status => 200,
+            :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "throws error if gist id not provided" do
+        expect { github.gists.comments nil}.to raise_error(ArgumentError)
+      end
+
+      it "should get the resources" do
+        github.gists.comments gist_id
+        a_get("/gists/#{gist_id}/comments").should have_been_made
+      end
+
+      it "should return array of resources" do
+        comments = github.gists.comments gist_id
+        comments.should be_an Array
+        comments.should have(1).items
+      end
+
+      it "should be a mash type" do
+        comments = github.gists.comments gist_id
+        comments.first.should be_a Hashie::Mash
+      end
+
+      it "should get gist information" do
+        comments = github.gists.comments gist_id
+        comments.first.user.login.should == 'octocat'
+      end
+
+      it "should yield to a block" do
+        github.gists.should_receive(:comments).with(gist_id).and_yield('web')
+        github.gists.comments(gist_id) { |param| 'web' }
+      end
+    end
+
+    context 'resource not found' do
+      before do
+        stub_get("/gists/#{gist_id}/comments").
+          to_return(:body => "", :status => [404, "Not Found"])
+      end
+
+      it "should return 404 with a message 'Not Found'" do
+        expect {
+          github.gists.comments gist_id
+        }.to raise_error(Github::ResourceNotFound)
+      end
+    end
+  end # comments
+
+  describe "#comment" do
+    context 'check aliases' do
+      it { github.gists.should respond_to :comment }
+      it { github.gists.should respond_to :get_comment }
+    end
+
+    context 'resource found' do
+      before do
+        stub_get("/gists/comments/#{comment_id}").
+          to_return(:body => fixture('gists/comment.json'),
+          :status => 200,
+          :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "should fail to get resource without comment id" do
+        expect { github.gists.comment nil }.to raise_error(ArgumentError)
+      end
+
+      it "should get the resource" do
+        github.gists.comment comment_id
+        a_get("/gists/comments/#{comment_id}").should have_been_made
+      end
+
+      it "should get comment information" do
+        comment = github.gists.comment comment_id
+        comment.id.should eq comment_id
+        comment.user.login.should == 'octocat'
+      end
+
+      it "should return mash" do
+        comment = github.gists.comment comment_id
+        comment.should be_a Hashie::Mash
+      end
+    end
+
+    context 'resource not found' do
+      before do
+        stub_get("/gists/comments/#{comment_id}").
+          to_return(:body => fixture('gists/comment.json'),
+            :status => 404,
+            :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "should fail to retrive resource" do
+        expect {
+          github.gists.comment comment_id
+        }.to raise_error(Github::ResourceNotFound)
+      end
+    end
+  end # comment
+
+  describe "#create_comment" do
+    let(:inputs) {
+      { "body" =>"Just commenting for the sake of commenting", "unrelated" => true }
+    }
+
+    context "resouce created" do
+      before do
+        stub_post("/gists/#{gist_id}/comments").
+          with(:body => JSON.generate(inputs.except('unrelated'))).
+          to_return(:body => fixture('gists/comment.json'),
+                :status => 201,
+                :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "should fail to create resource if 'content' input is missing" do
+        expect {
+          github.gists.create_comment gist_id, inputs.except('body')
+        }.to raise_error(ArgumentError)
+      end
+
+      it "should create resource successfully" do
+        github.gists.create_comment gist_id, inputs
+        a_post("/gists/#{gist_id}/comments").with(inputs).should have_been_made
+      end
+
+      it "should return the resource" do
+        comment = github.gists.create_comment gist_id, inputs
+        comment.should be_a Hashie::Mash
+      end
+
+      it "should get the comment information" do
+        comment = github.gists.create_comment gist_id, inputs
+        comment.user.login.should == 'octocat'
+      end
+    end
+
+    context "failed to create resource" do
+      before do
+        stub_post("/gists/#{gist_id}/comments").with(inputs).
+          to_return(:body => fixture('gists/comment.json'),
+            :status => 404,
+            :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "should faile to retrieve resource" do
+        expect {
+          github.gists.create_comment gist_id, inputs
+        }.to raise_error(Github::ResourceNotFound)
+      end
+    end
+  end # create_comment
+
+  describe "#edit_comment" do
+    let(:inputs) {
+      { "body" =>"Just commenting for the sake of commenting", "unrelated" => true }
+    }
+
+    context "resouce edited" do
+      before do
+        stub_patch("/gists/comments/#{comment_id}").
+          with(:body => JSON.generate(inputs.except('unrelated'))).
+          to_return(:body => fixture('gists/comment.json'),
+                :status => 201,
+                :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "should fail to create resource if 'content' input is missing" do
+        expect {
+          github.gists.edit_comment comment_id, inputs.except('body')
+        }.to raise_error(ArgumentError)
+      end
+
+      it "should create resource successfully" do
+        github.gists.edit_comment comment_id, inputs
+        a_patch("/gists/comments/#{comment_id}").with(inputs).should have_been_made
+      end
+
+      it "should return the resource" do
+        comment = github.gists.edit_comment comment_id, inputs
+        comment.should be_a Hashie::Mash
+      end
+
+      it "should get the comment information" do
+        comment = github.gists.edit_comment comment_id, inputs
+        comment.user.login.should == 'octocat'
+      end
+    end
+
+    context "failed to create resource" do
+      before do
+        stub_patch("/gists/comments/#{comment_id}").with(inputs).
+          to_return(:body => fixture('gists/comment.json'),
+            :status => 404,
+            :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "should faile to retrieve resource" do
+        expect {
+          github.gists.edit_comment comment_id, inputs
+        }.to raise_error(Github::ResourceNotFound)
+      end
+    end
+  end # edit_comment
+
+  describe "#delete_comment" do
+    context "resouce deleted" do
+      before do
+        stub_delete("/gists/comments/#{comment_id}").
+          to_return(:body => '',
+                :status => 204,
+                :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "should fail to create resource if 'content' input is missing" do
+        expect { github.gists.delete_comment nil }.to raise_error(ArgumentError)
+      end
+
+      it "should create resource successfully" do
+        github.gists.delete_comment comment_id
+        a_delete("/gists/comments/#{comment_id}").should have_been_made
+      end
+    end
+
+    context "failed to create resource" do
+      before do
+        stub_delete("/gists/comments/#{comment_id}").
+          to_return(:body => fixture('gists/comment.json'),
+            :status => 404,
+            :headers => {:content_type => "application/json; charset=utf-8"})
+      end
+
+      it "should faile to retrieve resource" do
+        expect {
+          github.gists.delete_comment comment_id
+        }.to raise_error(Github::ResourceNotFound)
+      end
+    end
+  end # delete_comment
+
 end # Github::Gists::Comments