githubris 0.0.4 → 0.0.5

data/lib/githubris/comment.rb

@@ -1,6 +1 @@
-class Githubris
-  class Comment
-    def self.build comment_data
-    end
-  end
-end
+class Githubris::Comment; end

data/lib/githubris/error.rb

@@ -0,0 +1,5 @@
+class Githubris::Error < StandardError; end
+class Githubris::Error::RequiresAuthentication < Githubris::Error; end
+class Githubris::Error::BadCredentials < Githubris::Error; end
+class Githubris::Error::NotFound < Githubris::Error; end
+class Githubris::Error::InvalidAttributes < Githubris::Error; end

data/lib/githubris/gist.rb

@@ -1,73 +1,28 @@
 require 'date'
 
-class Githubris::Gist
+class Githubris::Gist < Githubris::Base
   autoload :File, 'githubris/gist/file'
 
-  def self.default_attributes
-    {
-      :files => {},
-      :created_at => DateTime.now.to_s,
-      :updated_at => DateTime.now.to_s,
-    }
-  end
-
-  def initialize attributes={}
-    attributes.merge! Githubris::Gist.default_attributes do |given_key, given_value|
-      if Githubris::Gist.default_attributes.has_key? given_key
-        given_value
-      end
-    end
-
-    @attributes = attributes
-  end
+  include Githubris::Publicity
 
-  def id
-    Integer(@attributes[:id])
-  end
+  datetime_attribute :created_at, :updated_at
+  accessible_attribute :description
+  readable_attribute :id, :files
+  uri_attribute :url
 
   def user
-    unless @attributes[:user].instance_of? Githubris::User
-      @attributes[:user] = Githubris::Builder.new.build_user @attributes[:user]
-    else
-      @attributes[:user]
-    end
-  end
-
-  def created_at
-    DateTime.parse @attributes[:created_at]
-  end
-
-  def updated_at
-    DateTime.parse @attributes[:updated_at]
-  end
-
-  def description
-    @attributes[:description]
+    @user ||= Githubris::User.new(@attributes[:user])
   end
 
-  def files
-    @attributes[:files].values
-  end
-
-  def url
-    URI.parse @attributes[:url]
-  end
-
-  def public?
-    @attributes[:public]
-  end
-
-  def comments
-    Array.new @attributes[:comments], Githubris::Comment.new
-  end
-
-  def ==(other)
-    @attributes == other.instance_variable_get(:@attributes)
+  def reload
+    swap_attributes @api.get_gist @attributes[:id]
   end
 
-  def reload
-    other = Githubris::API.new.get_gist id
-    instance_variable_set(:@attributes, other.instance_variable_get(:@attributes))
-    self
+  def save
+    swap_attributes @api.post_gist(
+      :description => @attributes[:description],
+      :public => @attributes[:public],
+      :files => @attributes[:files]
+    )
   end
 end

data/lib/githubris/gist/file.rb

@@ -1,9 +1,2 @@
-class Githubris
-  class Gist
-    class File
-      def self.build data
-        new
-      end
-    end
-  end
+class Githubris::Gist::File
 end

data/lib/githubris/oauth.rb

@@ -0,0 +1,36 @@
+class Githubris::OAuth
+  REQUEST_ACCESS_URL = "https://github.com/login/oauth/authorize"
+
+  def initialize(client_id, client_secret)
+    @client_id = client_id
+    @client_secret = client_secret
+  end
+
+  def request_access_url(options={})
+    url = Addressable::URI.parse REQUEST_ACCESS_URL
+    query_values = {}
+    query_values[:client_id] = @client_id
+
+    redirect_uri = options.delete(:redirect_uri)
+    query_values[:redirect_uri] = redirect_uri if redirect_uri
+
+    scopes = options.delete :scopes
+    if scopes
+      scopes = scopes.join ','
+      query_values[:scopes] = scopes
+    end
+
+    url.query_values = query_values
+    url.query = URI.decode(url.query)
+    url.to_s
+  end
+
+  def access_token(code)
+    access_token_params = {
+      :client_id => @client_id,
+      :client_secret => @client_secret,
+      :code => code
+    }
+    Githubris::API.new.post_oauth_access_token(access_token_params)
+  end
+end

data/lib/githubris/publicity.rb

@@ -0,0 +1,13 @@
+module Githubris::Publicity
+  def public?
+    @attributes[:public]
+  end
+
+  def publicize
+    @attributes[:public] = true
+  end
+
+  def privatize
+    @attributes[:public] = false
+  end
+end

data/lib/githubris/user.rb

@@ -1,36 +1,21 @@
-class Githubris::User
-  def initialize attributes={}
-    @attributes = attributes
-  end
-
-  def public_gists
-    Githubris::API.new.get_user_public_gists(@attributes[:login])
-  end
-
-  def login
-    @attributes[:login]
-  end
-
-  def id
-    Integer(@attributes[:id])
-  end
-
-  def avatar_url
-    URI.parse @attributes[:avatar_url]
-  end
+class Githubris::User < Githubris::Base
+  uri_attribute :avatar_url, :url
+  readable_attribute :login, :id, :gravatar_id
 
-  def url
-    URI.parse @attributes[:url]
+  def gists(options={})
+    @api.get_user_gists(@attributes[:login])
   end
 
-  def gravatar_id
-    @attributes[:gravatar_id]
+  def starred_gists(options={})
+    @api.get_user_starred_gists(options)
   end
 
-  def == other
-    other_attrs = other.instance_variable_get(:@attributes)
-    if other_attrs
-      @attributes == other_attrs
+  def reload
+    swap_attributes @api.get_user @attributes[:login]
+  rescue Githubris::Error => error
+    case error
+    when Githubris::Error::NotFound
+      raise
     end
   end
 end

data/lib/githubris/version.rb

@@ -1,3 +1,3 @@
 class Githubris
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/githubris/api/gist_spec.rb

@@ -5,66 +5,33 @@ describe Githubris::API::Gist do
     Githubris::API.new
   end
 
-  describe '#get_user_public_gists' do
+  describe '#get_user_gists' do
+    use_vcr_cassette
+
     let(:login) {'GithubrisTestUser'}
 
     it 'gets /users/:username/gists' do
       subject.stub(:user_gists_path => '/users/GithubrisTestUser/gists')
-      user_public_gists = subject.get_user_public_gists(login)
+      user_public_gists = subject.get_user_gists(login)
       subject.should have_received(:user_gists_path).with(login)
     end
-
-    context 'given a user with 2 gists' do
-      it 'returns 2 gists by the given user' do
-        user_public_gists = subject.get_public_gists(:user => login)
-        user_public_gists.should have(2).items
-        user_public_gists.each do |gist|
-          gist.should be_instance_of Githubris::Gist
-        end
-      end
-    end
-
   end
 
   describe '#get_public_gists' do
+    use_vcr_cassette
+
     it 'returns an array of gists' do
       subject.get_public_gists.should be_instance_of Array
       subject.get_public_gists.each do |gist|
         gist.should be_instance_of Githubris::Gist
       end
     end
-
-    it 'accepts an options hash' do
-      lambda do
-        subject.get_public_gists({:foo => 'bar'})
-      end.should_not raise_error
-    end
-
-    context 'given a page option' do
-      it 'returns an array of 30 gists from that page' do
-        page_one_gists = subject.get_public_gists(:page => 1)
-        page_two_gists = subject.get_public_gists(:page => 2)
-        page_one_gists.should have(30).items
-        page_two_gists.should have(30).items
-      end
-    end
-
-    context 'given a user option' do
-      it 'delegates to #get_user_public_gists' do
-        login = 'GithubrisTestUser'
-        subject.should_receive(:get_user_public_gists).with(login)
-        subject.get_public_gists(:user => login)
-      end
-    end
   end
 
   describe '#get_gist' do
-    let(:id) { 1 }
-    it 'uses GET' do
-      subject.should_receive(:get).with(subject.gist_path(id))
-      subject.get_gist(id)
-    end
+    use_vcr_cassette
 
+    let(:id) { 1 }
     it 'is a Githubris::Gist' do
       subject.get_gist(id).should be_instance_of Githubris::Gist
     end

data/spec/githubris/api/user_spec.rb

@@ -2,12 +2,27 @@ require 'spec_helper'
 
 describe Githubris::API::User do
   let(:api) { Githubris::API.new }
+  subject { api }
+
+  describe '#get_authenticated_user' do
+    context 'without credentials' do
+      use_vcr_cassette
+
+      it 'raises a Githubris::Error::RequiresAuthentication' do
+        lambda do
+          subject.get_authenticated_user
+        end.should raise_error(Githubris::Error::RequiresAuthentication)
+      end
+    end
+  end
 
   describe '#get_user' do
-    subject { api.get_user('login') }
+    use_vcr_cassette
+
+    subject { api.get_user('GithubrisTestUser') }
     it 'takes a login' do
       lambda do
-        api.get_user('login')
+        api.get_user('GithubrisTestUser')
       end.should_not raise_error
     end
 

data/spec/githubris/api_spec.rb

@@ -1,4 +1,103 @@
 require 'spec_helper'
 
 describe Githubris::API do
+  let(:api) { Githubris::API.new }
+
+  describe '#authenticated?' do
+    it 'checks for an authenticated user' do
+      subject.should_receive(:get_authenticated_user)
+      subject.authenticated?
+    end
+
+    context 'when authenticated with good credentials' do
+      subject do
+        api.basic_auth('GithubrisTestUser', 'password')
+        api.authenticated?
+      end
+
+      use_vcr_cassette
+
+      it { should be_true }
+    end
+
+    context 'when authenticated with bad credentials' do
+      use_vcr_cassette
+
+      subject do
+        api.basic_auth('GithubrisTestFakeUser', 'password')
+        api.authenticated?
+      end
+
+      it { should be_false }
+    end
+
+    context 'when there are no credentials' do
+      use_vcr_cassette
+
+      subject do
+        api.authenticated?
+      end
+
+      it { should be_false }
+    end
+  end
+
+  describe '#oauth' do
+    it 'returns a Githubris::OAuth' do
+      client_id = 'client_id'
+      client_secret = 'client_secret'
+      subject.oauth(client_id, client_secret).should be_instance_of Githubris::OAuth
+    end
+
+    it 'returns a Githubris::OAuth initialized with the client id and secret' do
+      client_id = 'client_id'
+      client_secret = 'client_secret'
+      Githubris::OAuth.should_receive(:new).with(client_id, client_secret)
+      subject.oauth(client_id, client_secret)
+    end
+
+    it 'can take options' do
+      client_id = 'client_id'
+      client_secret = 'client_secret'
+      Githubris::OAuth.should_receive(:new).with(client_id, client_secret)
+      subject.oauth(client_id, client_secret)
+    end
+  end
+
+  describe '#post_oauth_access_token' do
+    use_vcr_cassette
+
+    before do
+      access_token_response =<<-RESPONSE
+HTTP/1.1 200 OK
+Server: nginx/1.0.13
+Date: Wed, 21 Mar 2012 12:54:41 GMT
+Content-Type: application/x-www-form-urlencoded; charset=utf-8
+Connection: keep-alive
+Status: 200 OK
+ETag: "fa6a87d35864200004d1eff50d685301"
+X-Frame-Options: deny
+X-Runtime: 14
+Content-Length: 71
+Cache-Control: private, max-age=0, must-revalidate
+Strict-Transport-Security: max-age=2592000
+
+access_token=1663860ddbbb9137119ff03ef2a9d819bbce4d0e&token_type=bearer
+RESPONSE
+      FakeWeb.register_uri(:post, /github.com\/login\/oauth\/access_token/, :response => access_token_response)
+    end
+
+    after do
+      FakeWeb.clean_registry
+    end
+
+    it 'takes params' do
+      lambda do
+        subject.post_oauth_access_token({})
+      end.should_not raise_error
+    end
+    it 'returns a string' do
+      subject.post_oauth_access_token({}).should be_instance_of String
+    end
+  end
 end

data/spec/githubris/base_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Githubris::Base do
+  it 'has an attributes hash' do
+    subject.instance_variable_get(:@attributes).should be_instance_of Hash
+  end
+
+  describe '#==' do
+    it 'matches based on attributes' do
+      object1 = described_class.new({:foo => 'bar'})
+      object2 = described_class.new({:foo => 'bar'})
+      object1.should == object2
+    end
+  end
+
+  context 'defining attributes' do
+    let(:mock_class) { Class.new(described_class) }
+
+    describe '::uri_attribute' do
+      it 'defines an instance method that returns a URI object' do
+        mock_class.class_eval do
+          uri_attribute :foo
+        end
+
+        object = mock_class.new(:foo => 'http://google.com')
+        object.foo.should be_kind_of URI
+      end
+    end
+
+    describe '::accessible_attribute' do
+      it 'defines an instance method that returns a URI object' do
+        mock_class.class_eval do
+          accessible_attribute :foo
+        end
+
+        lots_of_text = 'this is a lot of text'
+        object = mock_class.new(:foo => lots_of_text)
+
+        lambda do
+          object.foo == lots_of_text
+          object.foo = 'Not a ton of text'
+        end.should_not raise_error
+
+        object.foo.should == 'Not a ton of text'
+      end
+    end
+
+    describe '::datetime_attribute' do
+      it 'defines an instance method that returns a DateTime object' do
+        mock_class.class_eval do
+          datetime_attribute :foo
+        end
+
+        object = mock_class.new(:foo => '3:00PM 1/3/1994')
+        object.foo.should be_kind_of DateTime
+      end
+    end
+
+    describe '::readable_attribute' do
+      it 'defines a getter for the attributes passed in' do
+        mock_class.class_eval do
+          readable_attribute :foo, :bar, :baz
+        end
+
+        object = mock_class.new(:foo => 'asdf',
+                                :bar => 'fdsa',
+                                :baz => 'qwerty')
+
+        lambda do
+          object.foo.should == 'asdf'
+          object.bar.should == 'fdsa'
+          object.baz.should == 'qwerty'
+        end.should_not raise_error
+      end
+    end
+  end
+end