tuomas-tweetwine 0.1.8 → 0.1.9

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+=== 0.1.9 released 2009-07-15
+
+* Added commands "friends" and "followers"
+* Removed dependency to the "json" gem. It is included in Ruby 1.9.
+
 === 0.1.8 released 2009-07-01
 
 * SIGINT (Ctrl+c) is trapper earlier, resulting in clean abort while Ruby

data/README.rdoc

@@ -34,6 +34,8 @@ When invoking the program, the supported commands are
 <tt>mentions</tt>:: Fetch latest mentions for the authenticated user.
 <tt>user [name]</tt>:: Fetch a specific user's latest statuses, identified by the argument; if given no argument, fetch the statuses of the authenticated user.
 <tt>update [status]</tt>:: Send a status update, but confirm the action first before actually sending. The status update can either be given as an argument or via STDIN if no argument is given.
+<tt>friends</tt>:: Fetch friends and their latest statuses.
+<tt>followers</tt>:: Fetch followers and their latest statuses.
 
 If no <tt>[command]</tt> is given, the default action is <tt>home</tt>.
 

data/Rakefile

@@ -2,7 +2,7 @@ require "rubygems"
 
 full_name = "Tweetwine"
 package_name = "tweetwine"
-version = "0.1.8"
+version = "0.1.9"
 
 require "lib/#{package_name}"
 
@@ -23,7 +23,6 @@ spec = Gem::Specification.new do |s|
   s.files = FileList["Rakefile", "*.rdoc", "bin/**/*", "lib/**/*", "test/**/*"].to_a
   s.executables = ["tweetwine"]
 
-  s.add_dependency("json", ">= 1.1.4")
   s.add_dependency("rest-client", ">= 1.0.0")
 
   s.has_rdoc = true

data/lib/tweetwine/client.rb

@@ -7,7 +7,7 @@ module Tweetwine
   class Client
     attr_reader :num_statuses, :page_num
 
-    COMMANDS = [:home, :mentions, :user, :update]
+    COMMANDS = [:home, :mentions, :user, :update, :friends, :followers]
 
     DEFAULT_NUM_STATUSES = 20
     DEFAULT_PAGE_NUM = 1
@@ -24,15 +24,15 @@ module Tweetwine
     end
 
     def home
-      get_result_as_json_and_show "statuses/friends_timeline"
+      show_statuses(get_response_as_json("statuses/friends_timeline", :num_statuses, :page))
     end
 
     def mentions
-      get_result_as_json_and_show "statuses/mentions"
+      show_statuses(get_response_as_json("statuses/mentions", :num_statuses, :page))
     end
 
     def user(user = @username)
-      get_result_as_json_and_show "statuses/user_timeline/#{user}"
+      show_statuses(get_response_as_json("statuses/user_timeline/#{user}", :num_statuses, :page))
     end
 
     def update(new_status = nil)
@@ -44,12 +44,20 @@ module Tweetwine
       if !new_status.empty? && @io.confirm("Really send?")
         status = JSON.parse(post("statuses/update.json", {:status => new_status}))
         @io.info "Sent status update.\n\n"
-        @io.show_statuses([status])
+        show_statuses([status])
       else
         @io.info "Cancelled."
       end
     end
 
+    def friends
+      show_users(get_response_as_json("statuses/friends/#{@username}", :page))
+    end
+
+    def followers
+      show_users(get_response_as_json("statuses/followers/#{@username}", :page))
+    end
+
     private
 
     def parse_int_gt_option(value, default, min, name_for_error)
@@ -65,8 +73,50 @@ module Tweetwine
       end
     end
 
-    def get_result_as_json_and_show(url_body)
-      @io.show_statuses JSON.parse(get(url_body + ".json?count=#{@num_statuses}&page=#{@page_num}"))
+    def get_response_as_json(url_body, *query_opts)
+      url = url_body + ".json?#{parse_query_options(query_opts)}"
+      JSON.parse(get(url))
+    end
+
+    def parse_query_options(query_opts)
+      str = []
+      query_opts.each do |opt|
+        case opt
+        when :page
+          str << "page=#{@page_num}"
+        when :num_statuses
+          str << "count=#{@num_statuses}"
+        # do nothing on else
+        end
+      end
+      str.join("&")
+    end
+
+    def show_statuses(data)
+      show_responses(data) { |entry| [entry["user"], entry] }
+    end
+
+    def show_users(data)
+      show_responses(data) { |entry| [entry, entry["status"]] }
+    end
+
+    def show_responses(data)
+      data.each do |entry|
+        user_data, status_data = yield entry
+        @io.show(parse_response(user_data, status_data))
+      end
+    end
+
+    def parse_response(user_data, status_data)
+      record = { :user => user_data["screen_name"] }
+      if status_data
+        record[:status] = {
+          :created_at  => status_data["created_at"],
+          :in_reply_to => status_data["in_reply_to_screen_name"],
+          :text        => status_data["text"]
+        }
+      end
+      record
     end
 
     def get(body_url)

data/lib/tweetwine/io.rb

@@ -35,35 +35,48 @@ module Tweetwine
       confirmation.downcase[0,1] == "y"
     end
 
-    def show_statuses(statuses)
-      statuses.each { |status| show_status(status) }
+    def show(record)
+      if record[:status]
+        show_as_status(record)
+      else
+        show_as_user(record)
+      end
     end
 
-    private
-
-    def show_status(status)
-      time_diff_value, time_diff_unit = Util.humanize_time_diff(status["created_at"], Time.now)
-      from_user = status["user"]["screen_name"]
+    def show_as_status(record)
+      time_diff_value, time_diff_unit = Util.humanize_time_diff(record[:status][:created_at], Time.now)
+      from_user = record[:user]
       from_user = colorize(:green, from_user) if @colorize
-      in_reply_to = status["in_reply_to_screen_name"]
+      in_reply_to = record[:status][:in_reply_to]
       in_reply_to = if in_reply_to && !in_reply_to.empty?
         in_reply_to = colorize(:green, in_reply_to) if @colorize
         "in reply to #{in_reply_to}, "
       else
         ""
       end
-      text = status["text"]
+      status = record[:status][:text]
       if @colorize
-        text = colorize(:yellow, text, NICK_REGEX)
-        text = colorize(:cyan, text, URL_REGEX)
+        status = colorize(:yellow, status, NICK_REGEX)
+        status = colorize(:cyan, status, URL_REGEX)
       end
       @output.puts <<-END
 #{from_user}, #{in_reply_to}#{time_diff_value} #{time_diff_unit} ago:
-#{text}
+#{status}
 
       END
     end
 
+    def show_as_user(record)
+      user = record[:user]
+      user = colorize(:green, user) if @colorize
+      @output.puts <<-END
+#{user}
+
+      END
+    end
+
+    private
+
     def colorize(color, str, matcher = nil)
       color_code = COLOR_CODES[color.to_sym]
 

data/test/client_test.rb

@@ -46,116 +46,144 @@ class ClientTest < Test::Unit::TestCase
       @client = Client.new({ :username => "foo", :password => "bar" })
       @io = mock()
       @client.instance_variable_set(:@io, @io)
-      @query_params = "count=#{Client::DEFAULT_NUM_STATUSES}&page=#{Client::DEFAULT_PAGE_NUM}"
+      @statuses_query_params = "count=#{Client::DEFAULT_NUM_STATUSES}&page=#{Client::DEFAULT_PAGE_NUM}"
+      @users_query_params = "page=#{Client::DEFAULT_PAGE_NUM}"
     end
 
     should "raise ClientError for invalid request" do
       RestClient.expects(:get) \
-                .with("https://foo:bar@twitter.com/statuses/friends_timeline.json?#{@query_params}") \
+                .with("https://foo:bar@twitter.com/statuses/friends_timeline.json?#{@statuses_query_params}") \
                 .raises(RestClient::Unauthorized)
       assert_raises(ClientError) { @client.home }
     end
 
     should "fetch friends' statuses (home view)" do
-      statuses = [
+      statuses, records = create_test_statuses(
         {
-          "created_at" => Time.at(1).to_s,
-          "user" => { "username" => "zanzibar" },
-          "text" => "wassup?"
+          :user => "zanzibar",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "wassup?",
+            :in_reply_to  => nil
+          }
         },
         {
-          "created_at" => Time.at(2).to_s,
-          "user" => { "username" => "lulzwoo" },
-          "text" => "nuttin"
+          :user => "lulzwoo",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "nuttin'",
+            :in_reply_to  => nil
+          }
         }
-      ]
+      )
       RestClient.expects(:get) \
-                .with("https://foo:bar@twitter.com/statuses/friends_timeline.json?#{@query_params}") \
+                .with("https://foo:bar@twitter.com/statuses/friends_timeline.json?#{@statuses_query_params}") \
                 .returns(statuses.to_json)
-      @io.expects(:show_statuses).with(statuses)
+      @io.expects(:show).with(records[0])
+      @io.expects(:show).with(records[1])
       @client.home
     end
 
     should "fetch mentions" do
-      statuses = [
+      statuses, records = create_test_statuses(
         {
-          "created_at" => Time.at(1).to_s,
-          "in_reply_to_screen_name" => "foo",
-          "user" => { "username" => "zanzibar" },
-          "text" => "wassup, @foo?"
+          :user => "zanzibar",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "wassup, @foo?",
+            :in_reply_to  => "foo"
+          }
         },
         {
-          "created_at" => Time.at(2).to_s,
-          "in_reply_to_screen_name" => "foo",
-          "user" => { "username" => "lulzwoo" },
-          "text" => "@foo, doing nuttin"
+          :user => "lulzwoo",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "@foo, doing nuttin'",
+            :in_reply_to  => "foo"
+          }
         }
-      ]
+      )
       RestClient.expects(:get) \
-                .with("https://foo:bar@twitter.com/statuses/mentions.json?#{@query_params}") \
+                .with("https://foo:bar@twitter.com/statuses/mentions.json?#{@statuses_query_params}") \
                 .returns(statuses.to_json)
-      @io.expects(:show_statuses).with(statuses)
+      @io.expects(:show).with(records[0])
+      @io.expects(:show).with(records[1])
       @client.mentions
     end
 
     should "fetch a specific user's statuses, with the user identified by given argument" do
-      statuses = [
+      statuses, records = create_test_statuses(
         {
-          "created_at" => Time.at(1).to_s,
-          "user" => { "username" => "zanzibar" },
-          "text" => "wassup?"
+          :user => "zanzibar",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "wassup?",
+            :in_reply_to  => nil
+          }
         }
-      ]
+      )
       RestClient.expects(:get) \
-                .with("https://foo:bar@twitter.com/statuses/user_timeline/zanzibar.json?#{@query_params}") \
+                .with("https://foo:bar@twitter.com/statuses/user_timeline/zanzibar.json?#{@statuses_query_params}") \
                 .returns(statuses.to_json)
-      @io.expects(:show_statuses).with(statuses)
+      @io.expects(:show).with(records[0])
       @client.user("zanzibar")
     end
 
     should "fetch a specific user's statuses, with the user being the authenticated user itself when given no argument" do
-      statuses = [
+      statuses, records = create_test_statuses(
         {
-          "created_at" => Time.at(1).to_s,
-          "user" => { "username" => "foo" },
-          "text" => "wassup?"
+          :user => "foo",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "wassup?",
+            :in_reply_to  => nil
+          }
         }
-      ]
+      )
       RestClient.expects(:get) \
-                .with("https://foo:bar@twitter.com/statuses/user_timeline/foo.json?#{@query_params}") \
+                .with("https://foo:bar@twitter.com/statuses/user_timeline/foo.json?#{@statuses_query_params}") \
                 .returns(statuses.to_json)
-      @io.expects(:show_statuses).with(statuses)
+      @io.expects(:show).with(records[0])
       @client.user
     end
 
     should "post a status update via argument, when positive confirmation" do
-      status = {
-        "created_at" => Time.at(1).to_s,
-        "user" => { "username" => "foo" },
-        "text" => "wondering about"
-      }
+      statuses, records = create_test_statuses(
+        {
+          :user => "foo",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "wondering around",
+            :in_reply_to  => nil
+          }
+        },
+      )
       RestClient.expects(:post) \
                 .with("https://foo:bar@twitter.com/statuses/update.json", {:status => "wondering about"}) \
-                .returns(status.to_json)
+                .returns(statuses[0].to_json)
       @io.expects(:confirm).with("Really send?").returns(true)
       @io.expects(:info).with("Sent status update.\n\n")
-      @io.expects(:show_statuses).with([status])
+      @io.expects(:show).with(records[0])
       @client.update("wondering about")
     end
 
     should "post a status update via prompt, when positive confirmation" do
-      status = {
-        "created_at" => Time.at(1).to_s,
-        "user" => { "username" => "foo" },
-        "text" => "wondering about"
-      }
+      statuses, records = create_test_statuses(
+        { :user => "foo",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "wondering around",
+            :in_reply_to  => nil
+          }
+        },
+      )
       RestClient.expects(:post) \
                 .with("https://foo:bar@twitter.com/statuses/update.json", {:status => "wondering about"}) \
-                .returns(status.to_json)
+                .returns(statuses[0].to_json)
       @io.expects(:prompt).with("Status update").returns("wondering about")
       @io.expects(:confirm).with("Really send?").returns(true)
       @io.expects(:info).with("Sent status update.\n\n")
-      @io.expects(:show_statuses).with([status])
+      @io.expects(:show).with(records[0])
       @client.update
     end
 
@@ -163,8 +191,8 @@ class ClientTest < Test::Unit::TestCase
       RestClient.expects(:post).never
       @io.expects(:confirm).with("Really send?").returns(false)
       @io.expects(:info).with("Cancelled.")
-      @io.expects(:show_statuses).never
-      @client.update("wondering about")
+      @io.expects(:show).never
+      @client.update("wondering around")
     end
 
     should "cancel a status update via prompt, when negative confirmation" do
@@ -172,7 +200,7 @@ class ClientTest < Test::Unit::TestCase
       @io.expects(:prompt).with("Status update").returns("wondering about")
       @io.expects(:confirm).with("Really send?").returns(false)
       @io.expects(:info).with("Cancelled.")
-      @io.expects(:show_statuses).never
+      @io.expects(:show).never
       @client.update
     end
 
@@ -180,7 +208,7 @@ class ClientTest < Test::Unit::TestCase
       RestClient.expects(:post).never
       @io.expects(:confirm).never
       @io.expects(:info).with("Cancelled.")
-      @io.expects(:show_statuses).never
+      @io.expects(:show).never
       @client.update("")
     end
 
@@ -189,28 +217,85 @@ class ClientTest < Test::Unit::TestCase
       @io.expects(:prompt).with("Status update").returns("")
       @io.expects(:confirm).never
       @io.expects(:info).with("Cancelled.")
-      @io.expects(:show_statuses).never
+      @io.expects(:show).never
       @client.update
     end
 
     should "truncate a status update with too long argument and warn the user" do
       long_status_update = "x aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk lll mmm nnn ooo ppp qqq rrr sss ttt uuu vvv www xxx yyy zzz 111 222 333 444 555 666 777 888 999 000"
       truncated_status_update = "x aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk lll mmm nnn ooo ppp qqq rrr sss ttt uuu vvv www xxx yyy zzz 111 222 333 444 555 666 777 888 99"
-      status = {
-        "created_at" => Time.at(1).to_s,
-        "user" => { "username" => "foo" },
-        "text" => truncated_status_update
-      }
-
+      statuses, records = create_test_statuses(
+        { :user => "foo",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => truncated_status_update,
+            :in_reply_to  => nil
+          }
+        },
+      )
       RestClient.expects(:post) \
                 .with("https://foo:bar@twitter.com/statuses/update.json", {:status => truncated_status_update}) \
-                .returns(status.to_json)
+                .returns(statuses[0].to_json)
       @io.expects(:warn).with("Status will be truncated: #{truncated_status_update}")
       @io.expects(:confirm).with("Really send?").returns(true)
       @io.expects(:info).with("Sent status update.\n\n")
-      @io.expects(:show_statuses).with([status])
+      @io.expects(:show).with(records[0])
       @client.update(long_status_update)
     end
+
+    should "fetch friends" do
+      users, records = create_test_users(
+        {
+          :user => "zanzibar",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "wassup, @foo?",
+            :in_reply_to  => "foo"
+          }
+        },
+        {
+          :user => "lulzwoo",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "@foo, doing nuttin'",
+            :in_reply_to  => "foo"
+          }
+        }
+      )
+      RestClient.expects(:get) \
+                .with("https://foo:bar@twitter.com/statuses/friends/foo.json?#{@users_query_params}") \
+                .returns(users.to_json)
+      @io.expects(:show).with(records[0])
+      @io.expects(:show).with(records[1])
+      @client.friends
+    end
+
+    should "fetch followers" do
+      users, records = create_test_users(
+        {
+          :user => "zanzibar",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "wassup, @foo?",
+            :in_reply_to  => "foo"
+          }
+        },
+        {
+          :user => "lulzwoo",
+          :status => {
+            :created_at   => Time.at(1).to_s,
+            :text         => "@foo, doing nuttin'",
+            :in_reply_to  => "foo"
+          }
+        }
+      )
+      RestClient.expects(:get) \
+                .with("https://foo:bar@twitter.com/statuses/followers/foo.json?#{@users_query_params}") \
+                .returns(users.to_json)
+      @io.expects(:show).with(records[0])
+      @io.expects(:show).with(records[1])
+      @client.followers
+    end
   end
 end
 

data/test/io_test.rb

@@ -52,14 +52,24 @@ class IOTest < Test::Unit::TestCase
       @io = IO.new({ :input => @input, :output => @output, :colorize => false })
     end
 
-    should "print statuses without in-reply info" do
-      statuses = [
-        {
-          "created_at" => Time.at(1),
-          "user" => { "screen_name" => "fooman" },
-          "text" => "Hi, @barman! Lulz woo!"
+    should "output a record as user info when no status is given" do
+      record = { :user => "fooman" }
+      @output.expects(:puts).with(<<-END
+fooman
+
+      END
+      )
+      @io.show(record)
+    end
+
+    should "output record as a status when status is given, without in-reply info" do
+      record = {
+        :user   => "fooman",
+        :status => {
+          :created_at => Time.at(1),
+          :text       => "Hi, @barman! Lulz woo!"
         }
-      ]
+      }
       Util.expects(:humanize_time_diff).returns([2, "secs"])
       @output.expects(:puts).with(<<-END
 fooman, 2 secs ago:
@@ -67,26 +77,26 @@ Hi, @barman! Lulz woo!
 
       END
       )
-      @io.show_statuses(statuses)
+      @io.show(record)
     end
 
-    should "print statuses with in-reply info" do
-      statuses = [
-        {
-          "created_at" => Time.at(1),
-          "in_reply_to_screen_name" => "barman",
-          "user" => { "screen_name" => "fooman" },
-          "text" => "Hi, @barman! Lulz woo!"
+    should "output record as a status when status is given, with in-reply info" do
+      record = {
+        :user   => "barman",
+        :status => {
+          :created_at   => Time.at(1),
+          :text         => "Hi, @fooman! Check this: http://www.foo.com. Nice, isn't it?",
+          :in_reply_to  => "fooman"
         }
-      ]
+      }
       Util.expects(:humanize_time_diff).returns([2, "secs"])
       @output.expects(:puts).with(<<-END
-fooman, in reply to barman, 2 secs ago:
-Hi, @barman! Lulz woo!
+barman, in reply to fooman, 2 secs ago:
+Hi, @fooman! Check this: http://www.foo.com. Nice, isn't it?
 
       END
       )
-      @io.show_statuses(statuses)
+      @io.show(record)
     end
   end
 
@@ -97,14 +107,24 @@ Hi, @barman! Lulz woo!
       @io = IO.new({ :input => @input, :output => @output, :colorize => true })
     end
 
-    should "print statuses without in-reply info" do
-      statuses = [
-        {
-          "created_at" => Time.at(1),
-          "user" => { "screen_name" => "fooman" },
-          "text" => "Hi, @barman! Lulz woo!"
+    should "output a record as user info when no status is given" do
+      record = { :user => "fooman" }
+      @output.expects(:puts).with(<<-END
+\033[32mfooman\033[0m
+
+      END
+      )
+      @io.show(record)
+    end
+
+    should "output record as a status when status is given, without in-reply info" do
+      record = {
+        :user   => "fooman",
+        :status => {
+          :created_at => Time.at(1),
+          :text       => "Hi, @barman! Lulz woo!"
         }
-      ]
+      }
       Util.expects(:humanize_time_diff).returns([2, "secs"])
       @output.expects(:puts).with(<<-END
 \033[32mfooman\033[0m, 2 secs ago:
@@ -112,26 +132,26 @@ Hi, \033[33m@barman\033[0m! Lulz woo!
 
       END
       )
-      @io.show_statuses(statuses)
+      @io.show(record)
     end
 
-    should "print statuses with in-reply info" do
-      statuses = [
-        {
-          "created_at" => Time.at(1),
-          "in_reply_to_screen_name" => "barman",
-          "user" => { "screen_name" => "fooman" },
-          "text" => "Hi, @barman! Check this: http://www.foo.com. Nice, isn't it?"
+    should "output record as a status when status is given, with in-reply info" do
+      record = {
+        :user   => "barman",
+        :status => {
+          :created_at   => Time.at(1),
+          :text         => "Hi, @fooman! Check this: http://www.foo.com. Nice, isn't it?",
+          :in_reply_to  => "fooman"
         }
-      ]
+      }
       Util.expects(:humanize_time_diff).returns([2, "secs"])
       @output.expects(:puts).with(<<-END
-\033[32mfooman\033[0m, in reply to \033[32mbarman\033[0m, 2 secs ago:
-Hi, \033[33m@barman\033[0m! Check this: \033[36mhttp://www.foo.com\033[0m. Nice, isn't it?
+\033[32mbarman\033[0m, in reply to \033[32mfooman\033[0m, 2 secs ago:
+Hi, \033[33m@fooman\033[0m! Check this: \033[36mhttp://www.foo.com\033[0m. Nice, isn't it?
 
       END
       )
-      @io.show_statuses(statuses)
+      @io.show(record)
     end
   end
 

data/test/test_helper.rb

@@ -4,11 +4,43 @@ require "test/unit"
 require "shoulda"
 require "mocha"
 
+module Tweetwine
+  module TestHelpers
+    def create_test_statuses(*records)
+      statuses = records.map do |record|
+        {
+          "created_at"              => record[:status][:created_at],
+          "text"                    => record[:status][:text],
+          "in_reply_to_screen_name" => record[:status][:in_reply_to],
+          "user"                    => { "screen_name" => record[:user] }
+        }
+      end
+      [statuses, records]
+    end
+
+    def create_test_users(*records)
+      statuses = records.map do |record|
+        {
+          "screen_name" => record[:user],
+          "status"      => {
+            "created_at"              => record[:status][:created_at],
+            "text"                    => record[:status][:text],
+            "in_reply_to_screen_name" => record[:status][:in_reply_to],
+          }
+        }
+      end
+      [statuses, records]
+    end
+  end
+end
+
 Mocha::Configuration.prevent(:stubbing_non_existent_method)
 
 module Test
   module Unit
     class TestCase
+      include Tweetwine::TestHelpers
+
       def assert_full_match(regex, str, msg = "")
         match_data = regex.match(str)
         assert(str == match_data.to_s, msg)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tuomas-tweetwine
 version: !ruby/object:Gem::Version 
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors: 
 - Tuomas Kareinen
@@ -9,19 +9,9 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-01 00:00:00 -07:00
+date: 2009-07-15 00:00:00 -07:00
 default_executable: tweetwine
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: json
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.1.4
-    version: 
 - !ruby/object:Gem::Dependency 
   name: rest-client
   type: :runtime
@@ -63,7 +53,7 @@ homepage: http://github.com/tuomas/tweetwine
 post_install_message: 
 rdoc_options: 
 - --title
-- Tweetwine 0.1.8
+- Tweetwine 0.1.9
 - --main
 - README.rdoc
 - --exclude