rflak 0.3

data/README

@@ -0,0 +1,59 @@
+== rflak
+
+rflak is simple gem to use flaker.pl API. flaker.pl is polish microblogging website. For more information
+please visit http://flaker.pl.
+
+You can simply user two classes Flaker and Traker. Flaker class can fetch all entries scoped with
+conditions described in flaker's API. You can check API http://blog.flaker.pl/api described in polish.
+
+  Flaker.fetch('user') do |flak|
+    flak.login 'seban'
+    flak.limit 2
+    flak.tag 'ruby'
+  end
+
+With Traker class it is possible to fetch entries from traker
+service. You can visit http://flaker.pl/traker to see traker in your browser.
+
+  Traker.fetch do |traker|
+    traker.url 'http://blog.sebastiannowak.net'
+    traker.limit 20
+  end
+
+User operations
+
+Authenticate user by login and API key.
+
+  user = User.auth('my_login', 'my_api_key')
+  # user authenticated
+  user.nil? == false
+  # user not authenticated
+  user.nil? == true
+
+Create new entry, only authenticated user can post new entry
+
+  user = User.auth('my_login', 'my_api_key')
+  Entry.create(user, { :text => "My super text" }
+
+Get user's tags, bookmarks, followers and following users:
+
+  user.tags
+  user.bookmarks
+  user.followers
+  user.following
+
+Bookmark entry. Only authorized user can bookmark entry.
+
+  entry = Flaker.fetch('show' { |f| f.entry_id(123456) }
+  user = User.auth('my_login', 'my_api_key')
+  entry.bookmark(user) if user
+
+Add comments to some entry:
+
+  entry = Rflak::Flaker.fetch("show") { |f| f.entry_id '2725807' ; f.comments true }.first
+  user = Rflak::User.auth('my_login','my_api_key')
+  entry.comment(user,'my comment here')
+  # or
+  Comment.create(entry, user, 'my comment here')
+  # or
+  Comment.create(entry.id, user, 'my comment here')

data/lib/comment.rb

@@ -0,0 +1,56 @@
+module Rflak
+  # Class represents single comment assigned to 'flak'
+  class Comment < DummyEntry
+    ATTR_LIST = [:user, :permalink, :timestamp, :time, :text, :datetime, :source, :data, :subsource,
+      :url, :related_id
+    ]
+
+    # define attribute methods public getters and private setters
+    ATTR_LIST.each do |attr|
+      attr_reader attr
+
+      # user= method from dummy entry
+      unless attr == :user
+        attr_writer(attr)
+        protected attr.to_s + '='
+      end
+    end
+
+
+    def initialize(options = {})
+      options.each_pair do |key, value|
+        send("#{ key }=", value)
+      end
+    end
+
+
+    # Create new comment entry. Method raises NotAuthorized exception when passed user is not
+    # authorized. As entry parameter method takes <tt>Entry</tt> object or its <tt>id</tt> value.
+    # Content is passed as simply text message. When new comment is created <tt>true</tt> is returned
+    # otherwise returns <tt>false</tt>
+    #
+    # entry:: Entry || Fixnum
+    #
+    # user::  User
+    #
+    # returns:: Boolean
+    def self.create(entry, user, content)
+      raise NotAuthorized.new('Not authorized') unless user.authorized?
+
+      url = URI.parse('http://api.flaker.pl/api/type:submit')
+      post = Net::HTTP::Post.new(url.path)
+      post.basic_auth(user.login, user.api_key)
+
+      if entry.kind_of?(Entry)
+        post.set_form_data('text' => "@#{ entry.id } #{ content }")
+      else
+        post.set_form_data('text' => "@#{ entry } #{ content }")
+      end
+
+      response = Net::HTTP.start(url.host,url.port) do |http|
+        http.request(post)
+      end
+      response.code.to_i == 200
+    end
+  end
+end

data/lib/entry.rb

@@ -0,0 +1,146 @@
+require 'net/http'
+require 'json'
+module Rflak
+  # Class represents single entry in flaker.pl website. Entry is assigned with user to wich it belongs
+  # and can have many comments assigned to it.
+  class Entry < DummyEntry
+    ATTR_LIST = [:user, :permalink, :timestamp, :comments, :time, :text, :title, :has_video, :id,
+      :has_photo, :link, :has_link, :datetime, :source, :data, :subsource, :comments
+    ]
+
+    # define attribute methods public getters and private setters
+    ATTR_LIST.each do |attr|
+      attr_reader attr
+
+      # user= method from dummy entry
+      unless attr == :user
+        attr_writer(attr)
+        protected attr.to_s + '='
+      end
+    end
+
+    def initialize(options = {})
+      options.each_pair do |key, value|
+        send("#{ key }=", value)
+      end
+    end
+
+
+    # Create new entry. Method raises NotAuthorized exception when passed user is not authorized. If
+    # operation is successfull new entry will be returned.
+    #
+    #   Rflak::Entry.create(User.auth('good_login','good_api_key', { 'text' => 'some test content')
+    #
+    # user:: User
+    #
+    # content:: Hash
+    #
+    # returns:: Entry
+    def self.create(user, content)
+      raise NotAuthorized.new('Not authorized') unless user.authorized?
+
+      url = URI.parse('http://api.flaker.pl/api/type:submit')
+      post = Net::HTTP::Post.new(url.path)
+      post.basic_auth(user.login, user.api_key)
+      post.set_form_data(content)
+
+      response = Net::HTTP.start(url.host,url.port) do |http|
+        http.request(post)
+      end
+      entry_id = JSON.parse(response.body)['status']['info'].split('/').last
+      Flaker.fetch('show') { |f| f.entry_id(entry_id) }.first
+    end
+
+
+    # Mark entry as good "fajne!"
+    #
+    # user:: User
+    def good(user)
+      Entry.create(user, { 'text' => "@#{ self.id } fajne" })
+    end
+
+
+    # Mark entry as not good "niefajne!"
+    #
+    # user:: User
+    def not_good(user)
+      Entry.create(user, { 'text' => "@#{ self.id } niefajne" })
+    end
+
+    # Mark entry as lans "lans!"
+    #
+    # user:: User
+    def lans(user)
+      Entry.create(user, { 'text' => "@#{ self.id } lans" })
+    end
+
+
+    # Mark entry as stupid "głupie!"
+    #
+    # user:: User
+    def stupid(user)
+      Entry.create(user, { 'text' => "@#{ self.id } głupie" })
+    end
+
+
+    # Mark entry as bookmark
+    #
+    # user::  Rflak::User
+    def bookmark(user)
+      resp = Flaker.auth_connection(user) do |connection|
+        connection.get("/type:bookmark/action:set/entry_id:#{ self.id }")
+      end
+
+      if resp['status']['code'].to_i == 200
+        user.bookmarks
+      end
+    end
+
+
+    # Unmark entry as bookmark
+    #
+    # user::  Rflak::User
+    def unbookmark(user)
+      resp = Flaker.auth_connection(user) do |connection|
+        connection.get("/type:bookmark/action:unset/entry_id:#{ self.id }")
+      end
+
+      if resp['status']['code'].to_i == 200
+        user.bookmarks
+      end
+    end
+
+
+    # Add comment to entry. <tt>NotAuthorized</tt> exception will be raised if passed user is not
+    # authorized.
+    #
+    # user:: User
+    #
+    # content:: String
+    #
+    # returns:: Entry
+    def comment(user, content)
+      if Comment.create(self.id, user, content)
+        entry = Flaker.fetch("show") { |f| f.entry_id(self.id) ; f.comments(true) }.first
+        self.comments = entry.comments
+        return entry
+      else
+        self
+      end
+    end
+
+
+    private
+
+
+    # Set the comments collection based on passed value
+    #
+    # options:: Array of Hashes, default []
+    def comments=(collection = [])
+      @comments = [] and return if collection.empty?
+      @comments = collection.map do |comment_hash|
+        comment_hash.kind_of?(Rflak::Comment) ? comment_hash : Comment.new(comment_hash)
+      end
+    end
+  end
+end

data/lib/flaker.rb

@@ -0,0 +1,120 @@
+module Rflak
+  # Utility class for fetching 'flak's from the web.
+  #
+  # Example:
+  #   Flaker.fetch('user') do |flak|
+  #     flak.login 'seban'
+  #     flak.limit 2
+  #     flak.tag 'ruby'
+  #   end
+  class Flaker
+    include HTTParty
+
+    FLAK_API_URL = 'http://api.flaker.pl/api'
+    base_uri FLAK_API_URL
+
+    attr_reader :perform_url
+
+    def initialize(type)
+      @perform_url = FLAK_API_URL + "/type:#{ type }"
+    end
+
+
+    def self.fetch(type)
+      flak = Flaker.new(type)
+      yield(flak) if block_given?
+      parse_response get(flak.perform_url)
+    end
+
+
+    # Authorize connetion by user's credentials (login and api key) and perform instruction passed in
+    # block. Raises NotAuthorize exception when user has bad login or api key.
+    #
+    # user:: User
+    def self.auth_connection(user)
+      user.auth unless user.authorized?
+      raise NotAuthorized.new('Not authorized') unless user.authorized?
+      Flaker.basic_auth(user.login, user.api_key)
+      response = yield(Flaker)
+      Flaker.basic_auth('','')
+      return response
+    end
+
+
+    def self.parse_response(response)
+      response['entries'].map do |entry|
+        Entry.new(entry)
+      end
+    end
+
+
+    def login(value)
+      @perform_url += "/login:#{ value }"
+    end
+
+
+    def url(value)
+      @perform_url += "/url:#{ value }"
+    end
+
+
+    def entry_id(value)
+      @perform_url += "/entry_id:#{ value }"
+    end
+
+
+    def story(story_id)
+      @perform_url += "/story:#{ story_id }"
+    end
+
+
+    def source(value)
+      @perform_url += "/source:#{ value }"
+    end
+
+
+    def tag(value)
+      @perform_url += "/tag:#{ value }"
+    end
+
+
+    def mode(value)
+      @perform_url += "/mode:#{ value }"
+    end
+
+
+    def avatars(value)
+      @perform_url += "/avatars:#{ value }"
+    end
+
+
+    def limit(value)
+      @perform_url += "/limit:#{ value }"
+    end
+
+
+    def from(value)
+      @perform_url += "/from:#{ value }"
+    end
+
+
+    def start(value)
+      @perform_url += "/start:#{ value }"
+    end
+
+
+    def since(value)
+      @perform_url += "/since:#{ value }"
+    end
+
+
+    def sort(value)
+      @perform_url += "/sort:#{ value }"
+    end
+
+
+    def comments(value)
+      @perform_url += "/comments:#{ value }"
+    end
+  end
+end

data/lib/not_authorized.rb

@@ -0,0 +1,4 @@
+module Rflak
+  class NotAuthorized < RuntimeError
+  end
+end

data/lib/rflak.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'httparty'
+require 'not_authorized'
+require 'user'
+require 'dummy_entry'
+require 'entry'
+require 'comment'
+require 'traker'
+require 'flaker'

data/lib/traker.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'httparty'
+
+module Rflak
+  # Utility class to fetch entries from flaker.pl traker service
+  #
+  # Example:
+  #   Traker.fetch do |traker|
+  #     traker.url 'http://blog.sebastiannowak.net'
+  #     traker.limit 20
+  #   end
+  class Traker
+    include HTTParty
+
+    FLAK_API_URL = 'http://api.flaker.pl/api/type:traker'
+
+    attr_reader :perform_url
+
+    def initialize
+      @perform_url = FLAK_API_URL
+    end
+
+
+    def self.fetch
+      traker = Traker.new
+      yield(traker) if block_given?
+      parse_response get(traker.perform_url)
+    end
+
+
+    def url(url)
+      @perform_url += "/url:#{ url }"
+    end
+
+
+    def format(format)
+      @perform_url += "/format:#{ format }"
+    end
+
+
+    def avatars(size)
+      @perform_url += "/avatars:#{ size }"
+    end
+
+
+    def limit(value)
+      @perform_url += "/limit:#{ value }"
+    end
+
+
+    protected
+
+
+    def self.parse_response(response)
+      response['users'].map do |user_hash|
+        User.new(user_hash)
+      end
+    end
+  end
+end

data/lib/user.rb

@@ -0,0 +1,98 @@
+module Rflak
+  # Class represents single user of flaker.pl.
+  class User
+    ATTR_LIST = [:action, :url, :sex, :avatar, :login, :api_key]
+
+    # define attribute methods public getters and private setters
+    ATTR_LIST.each do |attr|
+      attr_reader attr
+      attr_writer(attr)
+      private attr.to_s + '='
+    end
+
+    def initialize(options = {})
+      options.each_pair do |key, value|
+        send("#{ key }=", value)
+      end
+    end
+
+
+    # Try to authorize user with login and api_key. Method returns User object for good credentails
+    # or nil for bad.
+    #
+    # login:: String
+    #
+    # api_key:: String
+    def self.auth(login, api_key)
+      user = User.new(:login => login, :api_key => api_key)
+      user.auth
+      user.authorized? ? user : nil
+    end
+
+
+    # Authorize User instance with login and api_key. Returns true for valid credentaials of false
+    # if not.
+    #
+    # returns:: True of False
+    def auth
+      Flaker.basic_auth(@login, @api_key)
+      resp = Flaker.get('/type:auth')
+      Flaker.basic_auth('', '')
+      @authorized = (resp['status']['code'] == "200")
+    end
+
+
+    # Returns true if User instance is authorized
+    #
+    # returns:: True or False
+    def authorized?
+      @authorized || false
+    end
+
+
+    # Returns array of watched tags. Raises Rflak::NotAuthorized if not authorized user
+    #
+    # returns:: Array
+    def tags
+      resp = Flaker.auth_connection(self) do |connection|
+        connection.get("/type:list/source:tags/login:#{ @login }")
+      end
+      return resp['tags']
+    end
+
+
+    # Returns array of favourited entries. Raises Rflak::NotAuthorized if not authorized user
+    #
+    # returns:: Array
+    def bookmarks
+      resp = Flaker.auth_connection(self) do |connection|
+        connection.get("/type:list/source:bookmarks/login:#{ @login }")
+      end
+      resp['bookmarks'].map do |id|
+        Flaker.fetch('show') { |flak| flak.entry_id(id) }
+      end
+    end
+
+
+    # Return login list of users that follow user
+    #
+    # returns:: Array
+    def followers
+      resp = Flaker.auth_connection(self) do |connection|
+        connection.get("/type:list/source:followedby/login:#{ @login }")
+      end
+      return resp['followedby']
+    end
+
+
+    # Returns login list of users following by user
+    #
+    # returns:: Array
+    def following
+      resp = Flaker.auth_connection(self) do |connection|
+        connection.get("/type:list/source:following/login:#{ @login }")
+      end
+      return resp['following']
+    end
+  end
+end

data/test/comment_test.rb

@@ -0,0 +1,68 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+require "test/unit"
+require 'rflak'
+require 'flexmock/test_unit'
+
+class CommentTest < Test::Unit::TestCase
+  def test_create_unauthorized_user
+    user = flexmock('user')
+    user.should_receive(:authorized?).and_return(false)
+
+    assert_raise(Rflak::NotAuthorized) do
+      Rflak::Comment.create(12345, user, 'test content')
+    end
+  end
+
+
+  def test_create_new_comment_with_entry_id
+    mock_post_request_to_api("200")
+
+    new_comment = Rflak::Comment.create(123456, mock_authorized_user, "My comment body.")
+    assert_equal true, new_comment
+  end
+
+
+  def test_create_new_comment_with_entry_object
+    mock_post_request_to_api("200")
+    entry = Rflak::Entry.new
+
+    new_comment = Rflak::Comment.create(entry, mock_authorized_user, "My comment body.")
+    assert_equal true, new_comment
+  end
+
+
+  def test_fail_create_new_comment_with_entry_id
+    mock_post_request_to_api("409")
+
+    new_comment = Rflak::Comment.create(123456, mock_authorized_user, "My comment body.")
+    assert_equal false, new_comment
+  end
+
+
+  def test_fail_create_new_comment_with_entry_object
+    mock_post_request_to_api("409")
+    entry = Rflak::Entry.new
+
+    new_comment = Rflak::Comment.create(entry, mock_authorized_user, "My comment body.")
+    assert_equal false, new_comment
+  end
+
+
+  protected
+
+
+  def mock_authorized_user
+    user = flexmock('user')
+    user.should_receive(:authorized?).and_return(true)
+    user.should_receive(:login).and_return('testuser')
+    user.should_receive(:api_key).and_return('test_api_key')
+    return user
+  end
+
+
+  def mock_post_request_to_api(status)
+    response = flexmock('response')
+    response.should_receive(:code).once.and_return(status)
+    flexmock(Net::HTTP).should_receive(:start).once.and_return(response)
+  end
+end

data/test/entry_test.rb

@@ -0,0 +1,163 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rflak'
+require 'flexmock/test_unit'
+
+class EntryTest < Test::Unit::TestCase
+  def setup
+    @hash = {
+      "user"=>{"action"=>"wrzuci\305\202 link na Flakera", "url"=>"http://flaker.pl/prawnik10",
+        "sex"=>"m", "avatar"=>"http://static0.flaker.pl/static/images/flaker/default_avatar_50.jpg",
+        "login"=>"prawnik10" },
+      "permalink"=>"http://flaker.pl/f/1899329",
+      "timestamp"=>"1245317709",
+      "time"=>"Thu, 18 Jun 2009 11:35:09 +0200",
+      "text"=>"Jakiś fajny tekst wrzucony na flakerka. Przepraszam oryginalnego autora - prawnik10 za zmianę ;)",
+      "source"=>"flaker",
+      "data"=>[],
+      "comments" => [
+        { "text" => "pi\u0119knie.... niez\u0142a kasa, bardzo niez\u0142a.",
+          "time" => "Fri, 18 Sep 2009 10:38:53 +0200",
+          "datetime" => "2009-09-18 10:38:53",
+          "timestamp" => "1253263133",
+          "permalink" => "http://flaker.pl/f/2605378-sicamp-wygral-projekt-roadar-ktory-bedzie-rowniez-realizowany-przez-polakow",
+          "user" => {
+            "login" =>"az",
+            "avatar" => "http:\static0.flaker.pl/static/images/flaker/user_generated/u_55_1238970606.jpg_50.jpeg",
+            "url" => "http://flaker.pl/az",
+            "sex" => "m" },
+          "related_id" => "2605378",
+          "subsource" => "internal_comment"}
+      ]
+    }
+
+    @entry = Rflak::Entry.new(@hash)
+  end
+
+
+  def test_respond_to_attribute_getters
+    [:user, :permalink, :timestamp, :comments, :time, :text, :title, :has_video, :id,
+      :has_photo, :link, :has_link, :datetime, :source, :data
+    ].each do |attribute|
+      assert @entry.respond_to?(attribute)
+    end
+  end
+
+
+  def test_new_object
+    assert_kind_of(Rflak::User, @entry.user)
+    assert_kind_of(Array, @entry.comments)
+    @entry.comments.each do |comment|
+      assert_kind_of(Rflak::Comment, comment)
+    end
+  end
+
+
+  def test_create_new_entry_unauthorized_user
+    user = flexmock('user')
+    user.should_receive(:authorized?).and_return(false)
+
+    assert_raise(Rflak::NotAuthorized) do
+      Rflak::Entry.create(user, 'text' => 'test content')
+    end
+  end
+
+
+  def test_create_new_entry_authorized_user
+    user = flexmock('user')
+    user.should_receive(:authorized?).and_return(true)
+    user.should_receive(:login).and_return('testuser')
+    user.should_receive(:api_key).and_return('test_api_key')
+    response_body =  "\r\n\r\n{\"status\":{\"code\":\"200\",\"text\":\"OK\",\"info\":\"http:\/\/flaker.pl\/f\/2077989\"}}"
+    response = flexmock('response')
+    response.should_receive(:body).and_return(response_body)
+    flexmock(Net::HTTP).should_receive(:start).and_return(response)
+    flexmock(Rflak::Flaker).should_receive(:fetch).and_return([Rflak::Entry.new])
+
+    response = Rflak::Entry.create(user, 'text' => 'test content')
+    assert_kind_of(Rflak::Entry, response)
+  end
+
+
+  def test_bookmark_authorized_user
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').and_return(auth_bad_credentials)
+    user = Rflak::User.new(:login => 'login', :api_key => 'bad_key')
+
+    assert_equal false, user.auth
+    assert_raise(Rflak::NotAuthorized) { @entry.bookmark(user) }
+  end
+
+
+  def test_bookmark_authorized_user
+    bookmark_response =  {"status"=>{"text"=>"OK", "code"=>"200", "info"=>"bookmark created"}}
+    bookmark_list_response = { 'bookmarks' => %w(1 2 3) }
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').once.and_return(auth_good_credentials)
+    flexmock(Rflak::Flaker).should_receive(:get).with("/type:bookmark/action:set/entry_id:#{ @entry.id }").times(1).and_return(bookmark_response)
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:list/source:bookmarks/login:login').times(1).and_return(bookmark_list_response)
+    flexmock(Rflak::Flaker).should_receive(:fetch).with("show", Proc).times(3).and_return(Rflak::Entry.new)
+
+    user = Rflak::User.new(:login => 'login', :api_key => 'good_key')
+
+    resp = @entry.bookmark(user)
+    assert_kind_of(Array, resp)
+    resp.each { |r| assert_kind_of(Rflak::Entry, r) }
+  end
+
+
+  def test_unbookmark_not_authorized_user
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').and_return(auth_bad_credentials)
+    user = Rflak::User.new(:login => 'login', :api_key => 'bad_key')
+
+    assert_equal false, user.auth
+    assert_raise(Rflak::NotAuthorized) { @entry.unbookmark(user) }
+  end
+
+
+  def test_unbookmark_authorized_user
+    bookmark_response =  {"status"=>{"text"=>"OK", "code"=>"200", "info"=>"i dont't know"}}
+    bookmark_list_response = { 'bookmarks' => %w(1 2 3) }
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').once.and_return(auth_good_credentials)
+    flexmock(Rflak::Flaker).should_receive(:get).with("/type:bookmark/action:unset/entry_id:#{ @entry.id }").times(1).and_return(bookmark_response)
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:list/source:bookmarks/login:login').times(1).and_return(bookmark_list_response)
+    flexmock(Rflak::Flaker).should_receive(:fetch).with("show", Proc).times(3).and_return(Rflak::Entry.new)
+
+    user = Rflak::User.new(:login => 'login', :api_key => 'good_key')
+
+    resp = @entry.unbookmark(user)
+    assert_kind_of(Array, resp)
+    resp.each { |r| assert_kind_of(Rflak::Entry, r) }
+  end
+
+
+  def test_comment
+    user = flexmock('user')
+    user.should_receive(:authorized?).and_return(true)
+    user.should_receive(:login).and_return('testuser')
+    user.should_receive(:api_key).and_return('test_api_key')
+
+    response = flexmock('response')
+    response.should_receive(:code).once.and_return("200")
+    flexmock(Net::HTTP).should_receive(:start).once.and_return(response)
+
+    entry_with_new_comment = @entry.clone
+    entry_with_new_comment.comments << Rflak::Comment.new(:text => "My comment")
+    flexmock(Rflak::Flaker).should_receive(:fetch).with("show", Proc).and_return([entry_with_new_comment])
+
+    resp = @entry.comment(user, "My comment")
+    assert_kind_of(Rflak::Entry, resp)
+  end
+
+
+  protected
+
+
+  def auth_bad_credentials
+    {"status" => {"code" => "401","text" => "Unauthorized","info" => "authorization is required"}}
+  end
+
+
+  def auth_good_credentials
+    { "status" => {"code" => "200","text" => "OK","info" =>"authorization successful"}}
+  end
+end

data/test/flaker_test.rb

@@ -0,0 +1,139 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'flaker'
+require 'rubygems'
+require 'flexmock/test_unit'
+
+class FlakerTest < Test::Unit::TestCase
+  def setup
+    @flak_connection = Rflak::Flaker.new('user')
+  end
+
+
+  def test_fetch
+    flexmock(Rflak::Flaker).should_receive(:get).and_return(flaker_fake_response).times(1)
+    response = Rflak::Flaker.fetch('user') do |conn|
+      conn.login 'dstranz'
+      conn.limit 2
+    end
+    assert_kind_of(Array, response)
+    response.each do |entry|
+      assert_kind_of(Rflak::Entry, entry)
+      assert_kind_of(Rflak::User, entry.user)
+    end
+  end
+
+
+  def test_login
+    assert_equal @flak_connection.perform_url + '/login:seban', @flak_connection.login('seban')
+  end
+
+
+  def test_url
+    assert_equal @flak_connection.perform_url + '/url:http://google.pl', @flak_connection.url('http://google.pl')
+  end
+
+
+  def test_entry_id
+    assert_equal @flak_connection.perform_url + '/entry_id:1', @flak_connection.entry_id(1)
+  end
+
+
+  def test_story
+    assert_equal @flak_connection.perform_url + '/story:1', @flak_connection.story(1)
+  end
+
+
+  def test_source
+    assert_equal @flak_connection.perform_url + '/source:photos', @flak_connection.source('photos')
+  end
+
+
+  def test_tag
+    assert_equal @flak_connection.perform_url + '/tag:ruby', @flak_connection.tag('ruby')
+  end
+
+
+  def test_mode
+    assert_equal @flak_connection.perform_url + '/mode:raw', @flak_connection.mode('raw')
+  end
+
+
+  def test_avatars
+    assert_equal @flak_connection.perform_url + '/avatars:small', @flak_connection.avatars('small')
+  end
+
+
+  def test_limit
+    assert_equal @flak_connection.perform_url + '/limit:50', @flak_connection.limit('50')
+  end
+
+
+  def test_from
+    assert_equal @flak_connection.perform_url + '/from:100', @flak_connection.from('100')
+  end
+
+
+  def test_start
+    assert_equal @flak_connection.perform_url + '/start:12345', @flak_connection.start('12345')
+  end
+
+
+  def test_sort
+    assert_equal @flak_connection.perform_url + '/sort:desc', @flak_connection.sort('desc')
+  end
+
+
+  def test_comments
+    assert_equal @flak_connection.perform_url + '/comments:false', @flak_connection.comments(false)
+  end
+
+
+  def test_since
+    assert_equal @flak_connection.perform_url + '/since:1234567', @flak_connection.since(1234567)
+  end
+
+
+  protected
+
+
+  def flaker_fake_response
+    # hard
+    { "user"=>{
+        "url" => "http://flaker.pl/dstranz",
+        "sex"=>"m",
+        "avatar"=>"http://static0.flaker.pl/static/images/flaker/user_generated/u_139_1227549010.jpg_50.jpeg",
+        "login"=>"dstranz"},
+      "entries"=>[
+        {"user" => {
+          "action" => "wrzuci\305\202 link na Flakera",
+          "url" => "http://flaker.pl/dstranz",
+          "sex"=> "m",
+          "avatar" => "http://static0.flaker.pl/static/images/flaker/user_generated/u_139_1227549010.jpg_50.jpeg",
+          "login"=>"dstranz" },
+        "permalink" => "http://flaker.pl/f/1909570",
+        "timestamp" => "1245366699",
+        "comments" => [],
+        "time"=> "Fri, 19 Jun 2009 01:11:39 +0200",
+        "text" => "tekst tekst tekst",
+        "title"=>"<!--deprecated-->",
+        "has_video"=>"0",
+        "id"=>"1909570",
+        "has_photo"=>"1",
+        "link"=>"",
+        "has_link"=>"1",
+        "datetime"=>"2009-06-19 01:11:39",
+        "source"=>"flaker",
+        "data" => {
+          "images"=>[
+            { "small"=>"f_139_1245369384_0_75.jpeg",
+              "big"=>"f_139_1245369384_0_495.jpeg",
+              "medium"=>"f_139_1245369384_0_285.jpeg",
+              "alt"=>"alt alt"
+            }]}
+        }
+      ]
+    }
+  end
+end

data/test/traker_test.rb

@@ -0,0 +1,66 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'traker'
+require 'rubygems'
+require 'flexmock/test_unit'
+
+class TrakerTest < Test::Unit::TestCase
+  def setup
+    @traker = Rflak::Traker.new
+  end
+
+
+  def test_fetch
+    flexmock(Rflak::Traker).new_instances.should_receive(:get).and_return(flaker_fake_response)
+    response = Rflak::Traker.fetch do |traker|
+      traker.url 'netguru.pl'
+      traker.limit 2
+    end
+    assert_kind_of(Array, response)
+    response.each do |user|
+      assert_kind_of(Rflak::User, user)
+    end
+  end
+
+
+  def test_url
+    assert_equal Rflak::Traker::FLAK_API_URL + "/url:http://flaker.pl", @traker.url('http://flaker.pl')
+  end
+
+
+  def test_format
+    assert_equal Rflak::Traker::FLAK_API_URL + '/format:raw', @traker.format('raw')
+  end
+
+
+  def test_avatars
+    assert_equal Rflak::Traker::FLAK_API_URL + '/avatars:medium', @traker.avatars('medium')
+  end
+
+
+  def test_limit
+    assert_equal Rflak::Traker::FLAK_API_URL + '/limit:10', @traker.limit(10)
+  end
+
+
+  protected
+
+
+  def flaker_fake_response
+    {
+      "site"=>{
+        "site_url"=>"http://netguru.pl",
+        "site_id"=>"2",
+        "site_createdon"=>"1205953764",
+        "site_deleted"=>"0",
+        "site_user_id"=>"55",
+        "site_name"=>"NETGURU" },
+      "users"=> [
+        { "url" => "http://flaker.pl/zuziak",
+          "avatar" => "http://static0.flaker.pl/static/images/flaker/user_generated/u_814_1244208247.jpg_50.jpeg",
+          "login"=>"zuziak" }
+      ]
+    }
+  end
+end

data/test/user_test.rb

@@ -0,0 +1,140 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rflak'
+require 'rubygems'
+require 'flexmock/test_unit'
+
+class UserTest < Test::Unit::TestCase
+  def setup
+    @user = Rflak::User.new
+  end
+
+
+  def test_respond_to_attribute_getters
+    [:action, :url, :sex, :avatar, :login].each do |attribute|
+      assert @user.respond_to?(attribute)
+    end
+  end
+
+
+  def test_auth_user_with_bad_credentials
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').and_return(auth_bad_credentials)
+    resp = Rflak::User.auth('login','bad_auth')
+    assert_nil(resp)
+  end
+
+
+  def test_auth_user_with_good_credentials
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').and_return(auth_good_credentials)
+    resp = Rflak::User.auth('login', 'good_auth')
+    assert_kind_of(Rflak::User, resp)
+    assert_equal 'login', resp.login
+    assert_equal 'good_auth', resp.api_key
+  end
+
+
+  def test_get_tags_not_authorized
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').and_return(auth_bad_credentials)
+    user = Rflak::User.new(:login => 'login', :api_key => 'bad_key')
+    assert_equal false, user.auth
+    exception = assert_raise(Rflak::NotAuthorized) { user.tags }
+    assert_equal 'Not authorized', exception.message
+  end
+
+
+  def test_get_tags_authorized
+    tag_list_response = { 'tags' => %w(tag1 tag2 tag3) }
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').once.and_return(auth_good_credentials)
+    flexmock(Rflak::Flaker).should_receive(:get).with("/type:list/source:tags/login:login").once.and_return(tag_list_response).times(1)
+    user = Rflak::User.new(:login => 'login', :api_key => 'good_key')
+    assert user.auth
+    tags = user.tags
+    assert_equal tag_list_response['tags'], tags
+  end
+
+
+  def test_get_bookmarks_not_authorized
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').and_return(auth_bad_credentials)
+    user = Rflak::User.new(:login => 'login', :api_key => 'bad_key')
+    assert_equal false, user.auth
+    exception = assert_raise(Rflak::NotAuthorized) { user.bookmarks }
+    assert_equal 'Not authorized', exception.message
+  end
+
+
+  def test_get_bookmarks_authorized
+    bookmark_list_response = { 'bookmarks' => %w(1 2 3) }
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').once.and_return(auth_good_credentials)
+    flexmock(Rflak::Flaker).should_receive(:get).with("/type:list/source:bookmarks/login:login").once.and_return(bookmark_list_response).times(1)
+    flexmock(Rflak::Flaker).should_receive(:fetch).with("show", Proc).times(3).and_return(Rflak::Entry.new)
+    user = Rflak::User.new(:login => 'login', :api_key => 'good_key')
+    assert user.auth
+    bookmarks = user.bookmarks
+    assert_equal 3, bookmarks.size
+    bookmarks.each do |bookmark|
+      assert_kind_of(Rflak::Entry, bookmark)
+    end
+  end
+
+
+  def test_get_followers_not_authorized
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').and_return(auth_bad_credentials)
+    user = Rflak::User.new(:login => 'login', :api_key => 'bad_key')
+    assert_equal false, user.auth
+    exception = assert_raise(Rflak::NotAuthorized) { user.followers }
+    assert_equal 'Not authorized', exception.message
+  end
+
+
+  def test_get_followers_authorized
+    followers_list_response = { 'followedby' => %w(seban) }
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').once.and_return(auth_good_credentials)
+    flexmock(Rflak::Flaker).should_receive(:get).with("/type:list/source:followedby/login:login").once.and_return(followers_list_response).times(1)
+
+    user = Rflak::User.new(:login => 'login', :api_key => 'good_key')
+    assert user.auth
+    followers = user.followers
+
+    assert_kind_of(Array, followers)
+    assert_equal 1, followers.size
+    followers.each { |f| assert_kind_of(String, f) }
+  end
+
+
+  def test_get_following_not_authorized
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').and_return(auth_bad_credentials)
+    user = Rflak::User.new(:login => 'login', :api_key => 'bad_key')
+    assert_equal false, user.auth
+    exception = assert_raise(Rflak::NotAuthorized) { user.following }
+    assert_equal 'Not authorized', exception.message
+  end
+
+
+  def test_get_following_authorized
+    following_list_response = { 'following' => %w(seban) }
+    flexmock(Rflak::Flaker).should_receive(:get).with('/type:auth').once.and_return(auth_good_credentials)
+    flexmock(Rflak::Flaker).should_receive(:get).with("/type:list/source:following/login:login").once.and_return(following_list_response).times(1)
+
+    user = Rflak::User.new(:login => 'login', :api_key => 'good_key')
+    assert user.auth
+    following = user.following
+
+    assert_kind_of(Array, following)
+    assert_equal 1, following.size
+    following.each { |f| assert_kind_of(String, f) }
+  end
+
+
+  protected
+
+
+  def auth_bad_credentials
+    {"status" => {"code" => "401","text" => "Unauthorized","info" => "authorization is required"}}
+  end
+
+
+  def auth_good_credentials
+    { "status" => {"code" => "200","text" => "OK","info" =>"authorization successful"}}
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: rflak
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- Sebastian Nowak
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-07 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |
+  Simple Ruby wrapper for Flaker service. Flaker is service collecting your network activities.
+  For more details go to http://flaker.pl
+
+email: sebastian.nowak@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/flaker.rb
+- lib/comment.rb
+- lib/not_authorized.rb
+- lib/rflak.rb
+- lib/traker.rb
+- lib/entry.rb
+- lib/user.rb
+- test/entry_test.rb
+- test/comment_test.rb
+- test/user_test.rb
+- test/traker_test.rb
+- test/flaker_test.rb
+- README
+has_rdoc: true
+homepage: http://github.com/seban/rflak/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple wraper for http://flaker.pl API
+test_files: []
+