twitter4r 0.1.0

data/lib/twitter.rb

@@ -0,0 +1,14 @@
+module Twitter; end
+
+def resolve_path(suffix)
+  File.expand_path(File.join(File.dirname(__FILE__), suffix))
+end
+
+# For better unicode support
+$KCODE = 'u'
+require 'jcode'
+
+# Ordering matters...pay attention here!
+require(resolve_path('twitter/version'))
+require(resolve_path('twitter/meta'))
+require(resolve_path('twitter/core'))

data/lib/twitter/core.rb

@@ -0,0 +1,179 @@
+# The Twitter4R API provides a nicer Ruby object API to work with 
+# instead of coding around the REST API.
+
+require('net/https')
+require('uri')
+require('json')
+
+# Encapsules the Twitter4R API.
+module Twitter
+  module ClassUtilMixin #:nodoc:
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+    end
+    
+    module InstanceMethods #:nodoc:
+      def initialize(params = {})
+        params.each do |key,val|
+          self.send("#{key}=", val) if self.respond_to? key
+        end
+      end
+    end
+  end # ClassUtilMixin
+  
+  # Error subclass raised when there is an error encountered upon 
+  # querying or posting to the REST API.
+  class RESTError < Exception
+    include ClassUtilMixin
+    attr_accessor :code, :message, :uri
+    
+    def to_s
+      "HTTP #{code}: #{message} at #{uri}"
+    end
+  end # RESTError
+
+  # Represents a user of Twitter
+  class User
+    include ClassUtilMixin
+    attr_accessor :id, :name, :description, :location, :screen_name, :url
+    
+    def eql?(obj)
+      [:id, :name, :description, :location, 
+      :screen_name, :url].each do |att|
+        return false if self.send(att).eql?(obj.send(att))
+      end or true
+    end
+  end # User
+  
+  # Represents a status posted to Twitter by a user of Twitter.
+  class Status
+    include ClassUtilMixin
+    attr_accessor :id, :text, :created_at, :user
+
+    def eql?(obj)
+      [:id, :text, :created_at, :user].each do |att|
+        return false if self.send(att).eql?(obj.send(att))
+      end or true
+    end
+  end # Status
+
+  # Used to query or post to the Twitter REST API to simplify code.
+  class Client
+    include ClassUtilMixin
+    attr_accessor :login, :password
+    
+    @@HOST = 'twitter.com'
+    @@PORT = 80
+    @@SSL = false
+    @@URIS = {:public => '/statuses/public_timeline.json',
+              :friends => '/statuses/friends_timeline.json',
+              :friends_statues => '/statuses/friends.json',
+              :followers => '/statuses/followers.json',
+              :update => '/statuses/update.json',
+              :send_direct_message => '/direct_messages/new.json', }
+
+    class << self
+      def config(conf)
+        @@HOST = conf[:host] if conf[:host]
+        @@PORT = conf[:port] if conf[:port]
+        @@SSL = conf[:use_ssl] if conf[:use_ssl] # getting ready for SSL support
+      end
+      
+      # Mostly helper method for irb shell prototyping
+      # TODO: move this out as class extension for twitter4r console script
+      def from_config(config_file, env = 'test')
+        yaml_hash = YAML.load(File.read(config_file))
+        self.new yaml_hash[env]
+      end
+    end # class << self
+
+    def timeline(type = :public)
+      http = Net::HTTP.new(@@HOST, @@PORT)
+      http.start do |http|
+        timeline_request(type, http)
+      end # http.start block
+    end # timeline
+    
+    def public_timeline
+      timeline :public
+    end
+    
+    def friend_timeline
+      timeline :friends
+    end
+    
+    def friend_statuses
+      timeline :friends_statuses
+    end
+
+    def follower_statuses
+      timeline :followers
+    end
+
+    def update(message)
+      uri = @@URIS[:update]
+      http = Net::HTTP.new(@@HOST, @@PORT)
+      http.start do |http|
+        request = Net::HTTP::Post.new(uri)
+        request.basic_auth(@login, @password)
+        response = http.request(request, "status=#{URI.escape(message)}")
+        handle_rest_response(response, uri)
+      end
+    end
+    
+    def send_direct_message(user, message)
+      login = user.respond_to?(:screen_name) ? user.screen_name : user
+      uri = @@URIS[:send_direct_message]
+      http = Net::HTTP.new(@@HOST, @@PORT)
+      http.start do |http|
+        request = Net::HTTP::Post.new(uri)
+        request.basic_auth(@login, @password)
+        response = http.request(request, "user=#{login}&text=#{URI.escape(message)}")
+        handle_rest_response(response, uri)
+      end
+    end
+
+    protected
+      attr_accessor :login, :password, :host, :port
+      
+      def unmarshall_statuses(status_array)
+        status_array.collect do |status|
+          Status.new(:id => status['id'], 
+                     :text => status['text'],
+                     :user => unmarshall_user(status['user']),
+                     :created_at => Time.parse(status['created_at'])
+                     )
+        end      
+      end
+      
+      def unmarshall_user(map)
+        User.new(:id => map['id'], :name => map['name'],
+                  :screen_name => map['screen_name'], 
+                  :description => map['description'],
+                  :location => map['location'],
+                  :url => map['url'])
+      end
+      
+      def timeline_request(type, http)
+        uri = @@URIS[type]
+        request = Net::HTTP::Get.new(uri)
+        request.basic_auth(@login, @password)
+        response = http.request(request)
+
+        handle_rest_response(response, uri)
+        unmarshall_statuses(JSON.parse(response.body))
+      end
+      
+      def raise_rest_error(response, uri = nil)
+        raise RESTError.new(:code => response.code, 
+                            :message => response.message,
+                            :uri => uri)        
+      end
+      
+      def handle_rest_response(response, uri)
+        unless ["200", "201"].member?(response.code)
+          raise_rest_error(response, uri)
+        end
+      end
+  end
+end

data/lib/twitter/meta.rb

@@ -0,0 +1,42 @@
+require('rubygems')
+require('erb')
+
+class Twitter::Meta #:nodoc:
+  attr_accessor :root_dir
+  attr_reader :pkg_info, :gem_spec, :project_files, :spec_files
+
+  def initialize(root_dir)
+    @root_dir = root_dir
+  end
+
+  def pkg_info
+    yaml_file = File.join(@root_dir, 'pkg-info.yml')
+    ryaml = ERB.new(File.read(yaml_file), 0)
+    s = ryaml.result(binding)
+    YAML.load(s)
+  end
+  
+  def spec_info
+    self.pkg_info['spec'] if self.pkg_info
+  end
+  
+  def project_files
+    @project_files ||= Dir.glob(File.join(@root_dir, 'lib/**/*.rb'))
+    @project_files
+  end
+  
+  def spec_files
+    @spec_files ||= Dir.glob(File.join(@root_dir, 'spec/**/*.rb'))
+    @spec_files
+  end
+  
+  def gem_spec
+    @gem_spec ||= Gem::Specification.new do |spec|
+      self.spec_info.each do |key, val|
+        spec.send("#{key}=", val)
+      end
+    end
+    @gem_spec
+  end
+end
+

data/lib/twitter/version.rb

@@ -0,0 +1,14 @@
+module Twitter::Version #:nodoc:
+  MAJOR = 0
+  MINOR = 1
+  REVISION = 0
+  class << self
+    def to_version
+      "#{MAJOR}.#{MINOR}.#{REVISION}"
+    end
+    
+    def to_name
+      "#{MAJOR}_#{MINOR}_#{REVISION}"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,86 @@
+require 'spec'
+require 'twitter'
+
+# Add helper methods here if relevant to multiple _spec.rb files
+
+# Spec helper that returns the project root directory as absolute path string
+def project_root_dir
+  File.expand_path(File.join(File.dirname(__FILE__), '..'))
+end
+
+# Spec helper that returns stubbed <tt>Net::HTTP</tt> object 
+# with given <tt>response</tt> and <tt>obj_stubs</tt>.
+# The <tt>host</tt> and <tt>port</tt> are used to initialize 
+# the Net::HTTP object.
+def stubbed_net_http(response, obj_stubs = {}, host = 'twitter.com', port = 80)
+  http = Net::HTTP.new(host, port)
+  Net::HTTP.stub!(:new).and_return(http)
+  http.stub!(:request).and_return(response)
+  http
+end
+
+# Spec helper that returns a mocked <tt>Net::HTTP</tt> object and 
+# stubs out the <tt>request</tt> method to return the given 
+# <tt>response</tt>
+def mas_net_http(response)
+  http = mock(Net::HTTP)
+  Net::HTTP.stub!(:new).and_return(http)
+  http.stub!(:request).and_return(response)
+  http.stub!(:start).and_yield(http)
+  http
+end
+
+# Spec helper that returns a mocked <tt>Net::HTTP::Get</tt> object and 
+# stubs relevant class methods and given <tt>obj_stubs</tt> 
+# for endo-specing
+def mas_net_http_get(obj_stubs = {})
+  request = Spec::Mocks::Mock.new(Net::HTTP::Get)
+  Net::HTTP::Get.stub!(:new).and_return(request)
+  obj_stubs.each do |method, value|
+    request.stub!(method).and_return(value)
+  end
+  request
+end
+
+# Spec helper that returns a mocked <tt>Net::HTTP::Post</tt> object and 
+# stubs relevant class methods and given <tt>obj_stubs</tt> 
+# for endo-specing
+def mas_net_http_post(obj_stubs = {})
+  request = Spec::Mocks::Mock.new(Net::HTTP::Post)
+  Net::HTTP::Post.stub!(:new).and_return(request)
+  obj_stubs.each do |method, value|
+    request.stub!(method).and_return(value)
+  end
+  request
+end
+
+# Spec helper that returns a mocked <tt>Net::HTTPResponse</tt> object and 
+# stubs given <tt>obj_stubs</tt> for endo-specing.
+# 
+def mas_net_http_response(status = :success, 
+                          body = '', 
+                          obj_stubs = {})
+  response = Spec::Mocks::Mock.new(Net::HTTPResponse)
+  response.stub!(:body).and_return(body)
+  case status
+  when :success || 200
+    _create_http_response(response, "200", "OK")
+  when :created || 201
+    _create_http_response(response, "201", "Created")
+  when :redirect || 301
+    _create_http_response(response, "301", "Redirect")
+  when :not_authorized || 403
+    _create_http_response(response, "403", "Not Authorized")
+  when :file_not_found || 404
+    _create_http_response(response, "404", "File Not Found")
+  when :server_error || 500
+    _create_http_response(response, "500", "Server Error")
+  end
+  response
+end
+
+# Local helper method to DRY up code.
+def _create_http_response(mock_response, code, message)
+  mock_response.stub!(:code).and_return(code)
+  mock_response.stub!(:message).and_return(message)
+end

data/spec/twitter/core_spec.rb

@@ -0,0 +1,430 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+context "Twitter::ClassUtilMixin mixed-in class" do
+  setup do
+    class TestClass
+      include Twitter::ClassUtilMixin
+      attr_accessor :var1, :var2, :var3
+    end
+    @init_hash = { :var1 => 'val1', :var2 => 'val2', :var3 => 'val3' }
+  end
+  
+  specify "should have Twitter::ClassUtilMixin as an included module" do
+    TestClass.included_modules.member?(Twitter::ClassUtilMixin).should.eql true
+  end
+
+  specify "should set attributes passed in the hash to TestClass.new" do
+    test = TestClass.new(@init_hash)
+    @init_hash.each do |key, val|
+      test.send(key).should.eql val
+    end
+  end
+  
+  specify "should not set attributes passed in the hash that are not attributes in TestClass.new" do
+    test = nil
+    lambda { test = TestClass.new(@init_hash.merge(:var4 => 'val4')) }.should_not_raise
+    test.respond_to?(:var4).should.eql false
+  end
+end
+
+context "Twitter::RESTError#to_s" do
+  setup do
+    @hash = { :code => 200, :message => 'OK', :uri => 'http://test.host/bla' }
+    @error = Twitter::RESTError.new(@hash)
+    @expected_message = "HTTP #{@hash[:code]}: #{@hash[:message]} at #{@hash[:uri]}"
+  end
+  
+  specify "should return @expected_message" do
+    @error.to_s.should.eql @expected_message
+  end
+end
+
+context "Twitter::Client" do
+  setup do
+    @init_hash = { :login => 'user', :password => 'pass' }
+  end
+
+  specify ".new should accept login and password as initializer hash keys and set the values to instance values" do
+    client = nil
+    lambda do
+      client = Twitter::Client.new(@init_hash)
+    end.should_not_raise
+    client.send(:login).should.eql @init_hash[:login]
+    client.send(:password).should.eql @init_hash[:password]
+  end  
+end
+
+context "Twitter::Client.config" do
+  setup do
+    @config_hash = { :host => 'test.host',
+                     :port => 443,
+                     :use_ssl => true, }
+  end
+  
+  specify "should override @@HOST and @@PORT if supplied" do
+    Twitter::Client.config @config_hash
+    host = Twitter::Client.class_eval("@@HOST")
+    host.should.eql @config_hash[:host]
+    port = Twitter::Client.class_eval("@@PORT")
+    port.should.eql @config_hash[:port]
+    ssl = Twitter::Client.class_eval("@@SSL")
+    ssl.should.eql @config_hash[:use_ssl]
+  end
+  
+  teardown do
+    Twitter::Client.config :host => 'twitter.com', :port => 80, :use_ssl => false
+  end
+end
+
+context "Twitter::Client#timeline(:public)" do
+  setup do
+    Twitter::Client.config(:port => 443, :use_ssl => false)
+    @host = Twitter::Client.class_eval("@@HOST")
+    @port = Twitter::Client.class_eval("@@PORT")
+
+    @request = mas_net_http_get(:basic_auth => nil)
+    @response = mas_net_http_response(:success, '[]')
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+    @login = @client.instance_eval("@login")
+    @password = @client.instance_eval("@password")
+  end
+ 
+  specify "should connect to the Twitter service via HTTP connection" do
+    Net::HTTP.should_receive(:new).with(@host, @port).once.and_return(@http)
+  	@client.timeline(:public)
+  end
+  
+  specify " should send HTTP Basic Authentication credentials" do
+    @request.should_receive(:basic_auth).with(@login, @password).once
+    @client.timeline(:public)
+  end
+end
+
+context "Twitter::Client#unmarshall_statuses" do
+  setup do
+    @json_hash = { "text" => "Thinking Zipcar is lame...",
+                   "id" => 46672912,
+                   "user" => {"name" => "Angie",
+                              "description" => "TV junkie...",
+                              "location" => "NoVA",
+                              "profile_image_url" => "http:\/\/assets0.twitter.com\/system\/user\/profile_image\/5483072\/normal\/eye.jpg?1177462492",
+                              "url" => nil,
+                              "id" => 5483072,
+                              "protected" => false,
+                              "screen_name" => "ang_410"},
+                   "created_at" => "Wed May 02 03:04:54 +0000 2007"}
+    @user = Twitter::User.new @json_hash["user"]
+    @status = Twitter::Status.new @json_hash
+    @status.user = @user
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+  end
+  
+  specify "should return expected populated Twitter::Status object values in an Array" do
+    statuses = @client.send(:unmarshall_statuses, [@json_hash])
+    statuses.should.have(1)
+    statuses.first.should.eql? @status
+  end
+end
+
+context "Twitter::Client#unmarshall_user" do
+  setup do
+    @json_hash = { "name" => "Lucy Snowe",
+                   "description" => "School Mistress Entrepreneur",
+                   "location" => "Villette",
+                   "url" => "http://villetteschoolforgirls.com",
+                   "id" => 859303,
+                   "protected" => true,
+                   "screen_name" => "LucyDominatrix", }
+    @user = Twitter::User.new @json_hash
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+  end
+  
+  specify "should return expected populated Twitter::User object value" do
+    user = @client.send(:unmarshall_user, @json_hash)
+    user.should.eql? @user
+  end
+end
+
+context "Twitter::Client#timeline_request upon 200 HTTP response" do
+  setup do
+    @request = mas_net_http_get :basic_auth => nil
+    @response = mas_net_http_response # defaults to :success
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+    @uris = Twitter::Client.class_eval("@@URIS")
+    
+    JSON.stub!(:parse).and_return({})
+  end
+  
+  specify "should make GET HTTP request to appropriate URL" do
+    @uris.keys.each do |type|
+      Net::HTTP::Get.should_receive(:new).with(@uris[type]).and_return(@request)
+      @client.send(:timeline_request, type, @http)
+    end
+  end
+end
+
+context "Twitter::Client#timeline_request upon 403 HTTP response" do
+  setup do
+    @request = mas_net_http_get :basic_auth => nil
+    @response = mas_net_http_response :not_authorized
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+    @uris = Twitter::Client.class_eval("@@URIS")
+  end
+  
+  specify "should make GET HTTP request to appropriate URL" do
+    @uris.keys.each do |type|
+      lambda do
+        Net::HTTP::Get.should_receive(:new).with(@uris[type]).and_return(@request)
+        @client.send(:timeline_request, type, @http)
+      end.should_raise(Twitter::RESTError)
+    end
+  end
+end
+
+context "Twitter::Client#timeline_request upon 500 HTTP response" do
+  setup do
+    @request = mas_net_http_get(:basic_auth => nil)
+    @response = mas_net_http_response(:server_error)
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+    @uris = Twitter::Client.class_eval("@@URIS")
+  end
+  
+  specify "should make GET HTTP request to appropriate URL" do
+    @uris.keys.each do |type|
+      lambda do
+        Net::HTTP::Get.should_receive(:new).with(@uris[type]).and_return(@request)
+        @client.send(:timeline_request, type, @http)
+      end.should_raise(Twitter::RESTError)
+    end
+  end
+end
+
+context "Twitter::Client#timeline_request upon 404 HTTP response" do
+  setup do
+    @request = mas_net_http_get(:basic_auth => nil)
+    @response = mas_net_http_response(:file_not_found)
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+    @uris = Twitter::Client.class_eval("@@URIS")
+  end
+  
+  specify "should make GET HTTP request to appropriate URL" do
+    @uris.keys.each do |type|
+      lambda do
+        Net::HTTP::Get.should_receive(:new).with(@uris[type]).and_return(@request)
+        @client.send(:timeline_request, type, @http)
+      end.should_raise(Twitter::RESTError)
+    end
+  end
+end
+
+context "Twitter::Client#update(msg) upon 200 HTTP response" do
+  setup do
+    @request = mas_net_http_post(:basic_auth => nil)
+    @response = mas_net_http_response
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+    @expected_uri = Twitter::Client.class_eval("@@URIS[:update]")
+    
+    @message = "We love Jodhi May!"
+  end
+  
+  specify "should make POST HTTP request to appropriate URL" do
+    Net::HTTP::Post.should_receive(:new).with(@expected_uri).and_return(@request)
+    @client.update(@message)
+  end
+end
+
+context "Twitter::Client#update(msg) upon 500 HTTP response" do
+  setup do
+    @request = mas_net_http_post(:basic_auth => nil)
+    @response = mas_net_http_response(:server_error)
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+    @expected_uri = Twitter::Client.class_eval("@@URIS[:update]")
+    
+    @message = "We love Jodhi May!"
+  end
+  
+  specify "should make POST HTTP request to appropriate URL" do
+    lambda do
+      Net::HTTP::Post.should_receive(:new).with(@expected_uri).and_return(@request)
+      @client.update(@message)
+    end.should_raise(Twitter::RESTError)
+  end
+end
+
+context "Twitter::Client#public_timeline" do
+  setup do
+    @request = mas_net_http_get(:basic_auth => nil)
+    @response = mas_net_http_response
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+  end
+  
+  specify "should delegate work to Twitter::Client#public(:public)" do
+    @client.should_receive(:timeline).with(:public).once
+    @client.public_timeline
+  end
+end
+
+context "Twitter::Client#friend_timeline" do
+  setup do
+    @request = mas_net_http_get(:basic_auth => nil)
+    @response = mas_net_http_response
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+  end
+  
+  specify "should delegate work to Twitter::Client#public(:friends)" do
+    @client.should_receive(:timeline).with(:friends).once
+    @client.friend_timeline
+  end
+end
+
+context "Twitter::Client#friend_statuses" do
+  setup do
+    @request = mas_net_http_get(:basic_auth => nil)
+    @response = mas_net_http_response
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+  end
+  
+  specify "should delegate work to Twitter::Client#public(:friends_statuses)" do
+    @client.should_receive(:timeline).with(:friends_statuses).once
+    @client.friend_statuses
+  end
+end
+
+context "Twitter::Client#follower_statuses" do
+  setup do
+    @request = mas_net_http_get(:basic_auth => nil)
+    @response = mas_net_http_response
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+  end
+  
+  specify "should delegate work to Twitter::Client#public(:followers)" do
+    @client.should_receive(:timeline).with(:followers).once
+    @client.follower_statuses
+  end
+end
+
+context "Twitter::Client#send_direct_message" do
+  setup do
+    @request = mas_net_http_post(:basic_auth => nil)
+    @response = mas_net_http_response
+    
+    @http = mas_net_http(@response)
+    @client = Twitter::Client.from_config 'config/twitter.yml'
+    
+    @login = @client.instance_eval("@login")
+    @password = @client.instance_eval("@password")
+    
+    @user = mock(Twitter::User)
+    @user.stub!(:screen_name).and_return("twitter4r")
+
+    @message = "This is a test direct message from twitter4r RSpec specifications"
+    @expected_uri = '/direct_messages/new.json'
+    @expected_params = "user=#{@user.screen_name}&text=#{URI.escape(@message)}"
+  end
+  
+  specify "should convert given Twitter::User object to screen name" do
+    @user.should_receive(:screen_name).once
+    @client.send_direct_message(@user, @message)
+  end
+  
+  specify "should POST to expected URI" do
+    Net::HTTP::Post.should_receive(:new).with(@expected_uri).once.and_return(@request)
+    @client.send_direct_message(@user, @message)
+  end
+  
+  specify "should login via HTTP Basic Authentication using expected credentials" do
+    @request.should_receive(:basic_auth).with(@login, @password).once
+    @client.send_direct_message(@user, @message)
+  end
+  
+  specify "should make POST request with expected URI escaped parameters" do
+    @http.should_receive(:request).with(@request, @expected_params).once.and_return(@response)
+    @client.send_direct_message(@user, @message)
+  end
+end
+
+context "Twitter::Status#eql?" do
+  setup do
+    @attr_hash = { :text => 'Status', :id => 34329594003, 
+                   :user => { :name => 'Tess',
+                              :description => "Unfortunate D'Urberville",
+                              :location => 'Dorset',
+                              :url => nil,
+                              :id => 34320304,
+                              :screen_name => 'maiden_no_more' }, 
+                   :created_at => 'Wed May 02 03:04:54 +0000 2007'}
+    @obj = Twitter::Status.new @attr_hash
+    @other = Twitter::Status.new @attr_hash
+  end
+  
+  specify "should return true when non-transient object attributes are eql?" do
+    @obj.should.eql? @other
+    @obj.eql?(@other).should.eql? true # for the sake of getting rcov to recognize this method is covered in the specs
+  end
+
+  specify "should return false when not all non-transient object attributes are eql?" do
+    @other.created_at = Time.now.to_s
+    @obj.should.not.eql? @other
+    @obj.eql?(@other).should.eql? false # for the sake of getting rcov to recognize this method is covered in the specs
+  end
+  
+  specify "should return true when comparing same object to itself" do
+    @obj.should.eql? @obj
+    @obj.eql?(@obj).should.eql? true # for the sake of getting rcov to recognize this method is covered in the specs
+    @other.should.eql? @other
+    @other.eql?(@other).should.eql? true # for the sake of getting rcov to recognize this method is covered in the specs
+  end
+end
+
+context "Twitter::User#eql?" do
+  setup do
+    @attr_hash = { :name => 'Elizabeth Jane Newson-Henshard',
+                   :description => "Wronged 'Daughter'",
+                   :location => 'Casterbridge',
+                   :url => nil,
+                   :id => 6748302,
+                   :screen_name => 'mayors_daughter_or_was_she?' }
+    @obj = Twitter::User.new @attr_hash
+    @other = Twitter::User.new @attr_hash
+  end
+  
+  specify "should return true when non-transient object attributes are eql?" do
+    @obj.should.eql? @other
+    @obj.eql?(@other).should.eql? true
+  end
+  
+  specify "should return false when not all non-transient object attributes are eql?" do
+    @other.id = 1
+    @obj.should.not.eql? @other
+    @obj.eql?(@other).should.eql? false
+  end
+  
+  specify "should return true when comparing same object to itself" do
+    @obj.should.eql? @obj
+    @obj.eql?(@obj).should.eql? true
+    @other.should.eql? @other
+    @obj.eql?(@obj).should.eql? true
+  end
+end

data/spec/twitter/meta_spec.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+def glob_files(*path_elements)
+  Dir.glob(File.join(*path_elements))
+end
+
+def load_erb_yaml(path, context)
+  ryaml = ERB.new(File.read(path), 0)
+  YAML.load(ryaml.result(context))
+end
+
+module ERBMetaMixin
+  # Needed to make the YAML load work...
+  def project_files
+    glob_files(@root_dir, 'lib', '**/*.rb')
+  end
+
+  # Needed to make the YAML load work...
+  def spec_files
+    glob_files(@root_dir, 'spec', '**/*.rb')
+  end
+end
+
+context "Twitter::Meta cache policy" do
+  include ERBMetaMixin
+  setup do
+    @root_dir = project_root_dir
+    @meta = Twitter::Meta.new(@root_dir)
+    @expected_pkg_info = load_erb_yaml(File.join(@root_dir, 'pkg-info.yml'), binding)
+    @expected_project_files = project_files
+    @expected_spec_files = spec_files
+  end
+  
+  specify "should store value returned from pkg_info in @pkg_info after first YAML load" do
+    @meta.instance_eval("@pkg_info").should.eql?(nil)
+    @meta.pkg_info
+    @meta.instance_eval("@pkg_info").should_eql?(@expected_pkg_info)
+    @meta.pkg_info
+    @meta.instance_eval("@pkg_info").should_eql?(@expected_pkg_info)
+  end
+  
+  specify "should store value returned from project_files in @project_files after first glob" do
+    @meta.instance_eval("@project_files").should.eql?(nil)
+    @meta.project_files
+    @meta.instance_eval("@project_files").should.eql?(@expected_project_files)
+    @meta.project_files
+    @meta.instance_eval("@project_files").should.eql?(@expected_project_files)
+  end
+  
+  specify "should store value returned from spec_files in @spec_files after first glob" do
+    @meta.instance_eval("@spec_files").should.eql?(nil)
+    @meta.spec_files
+    @meta.instance_eval("@spec_files").should.eql?(@expected_spec_files)
+    @meta.spec_files
+    @meta.instance_eval("@spec_files").should.eql?(@expected_spec_files)
+  end
+end
+
+context "Twitter::Meta" do
+  include ERBMetaMixin
+  setup do
+    @root_dir = project_root_dir
+    @meta = Twitter::Meta.new(@root_dir)
+    @expected_yaml_hash = load_erb_yaml(File.join(@root_dir, 'pkg-info.yml'), binding)
+    @expected_project_files = project_files
+    @expected_spec_files = spec_files
+  end
+  
+  specify "should load and return YAML file into Hash object upon #pkg_info call" do
+    yaml_hash = @meta.pkg_info
+    yaml_hash.should.eql? @expected_yaml_hash
+  end
+  
+  specify "should return the embedded hash responding to key 'spec' of #pkg_info call upon #spec_info call" do
+    yaml_hash = @meta.spec_info
+    yaml_hash.should.eql? @expected_yaml_hash['spec']
+  end
+  
+  specify "should return list of files matching ROOT_DIR/lib/**/*.rb upon #project_files call" do
+    project_files = @meta.project_files
+    project_files.should.eql? @expected_project_files
+  end
+  
+  specify "should return list of files matching ROOT_DIR/spec/**/*.rb upon #spec_files call" do
+    spec_files = @meta.spec_files
+    spec_files.should.eql? @expected_spec_files    
+  end
+  
+  specify "should return Gem specification based on YAML file contents and #project_files and #spec_files return values" do
+    spec = @meta.gem_spec
+    expected_spec_hash = @expected_yaml_hash['spec']
+    expected_spec_hash.each do |key, val|
+      spec.send(key).should.eql? expected_spec_hash[key]
+    end
+  end
+end

data/spec/twitter/version_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+VERSION_LIST = [Twitter::Version::MAJOR, Twitter::Version::MINOR, Twitter::Version::REVISION]
+
+EXPECTED_VERSION = VERSION_LIST.join('.')
+EXPECTED_NAME = VERSION_LIST.join('_')
+
+context "Twitter::Version.to_version" do
+  specify "should return #{EXPECTED_VERSION}" do
+    Twitter::Version.to_version.should.eql EXPECTED_VERSION
+  end
+end
+
+context "Twitter::Version.to_name" do
+  specify "should return #{EXPECTED_NAME}" do
+    Twitter::Version.to_name.should.eql EXPECTED_NAME
+  end
+end
+

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: twitter4r
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-06 00:00:00 -05:00
+summary: A clean Twitter client API in pure Ruby (not command-line client). Will include Twitter add-ons also in Ruby.
+require_paths: 
+- lib
+email: twitter4r-devel@rubyforge.org
+homepage: http://twitter4r.rubyforge.org
+rubyforge_project: twitter4r
+description: 
+autorequire: twitter
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Susan Potter
+files: 
+- lib/twitter.rb
+- lib/twitter/version.rb
+- lib/twitter/meta.rb
+- lib/twitter/core.rb
+- spec/spec_helper.rb
+- spec/twitter/core_spec.rb
+- spec/twitter/version_spec.rb
+- spec/twitter/meta_spec.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+