794 lines
22 KiB
EmacsLisp
794 lines
22 KiB
EmacsLisp
;;; identica-friends.el ---
|
|
;;
|
|
;; Filename: identica-friends.el
|
|
;; Description: A library that provides some functions to look who are your friends in your identi.ca account.
|
|
;; Author: Christian Giménez
|
|
;; Maintainer:
|
|
;; Created: dom sep 25 17:58:40 2011 (-0300)
|
|
;; Version:
|
|
;; Last-Updated:
|
|
;; By:
|
|
;; Update #: 0
|
|
;; URL:
|
|
;; Keywords:
|
|
;; Compatibility:
|
|
;;
|
|
;; Features that might be required by this library:
|
|
;;
|
|
;; None
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Commentary:
|
|
;;
|
|
;; Use M-x identica first, if you are not connected, this library
|
|
;; will not work.
|
|
;; You can check who are your friends on Identi.ca using the function
|
|
;; M-x identica-show-friends
|
|
;; If you want to check who are following you, type:
|
|
;; M-x identica-show-followers
|
|
;;
|
|
;; I divided the code into sections. This sections are tabbed asside
|
|
;; and commented by an only one ";". Also are overlined and underlined
|
|
;; so, they are very visible.
|
|
;;
|
|
;; Convention:
|
|
;; All functions and variables in this modules has the prefix
|
|
;; "identica-friends" so you can identify easyly.
|
|
;; The main functions may not have this prefix so users don't get
|
|
;; confused.
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Change Log:
|
|
;;
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;; This program is free software; you can redistribute it and/or
|
|
;; modify it under the terms of the GNU General Public License as
|
|
;; published by the Free Software Foundation; either version 3, or
|
|
;; (at your option) any later version.
|
|
;;
|
|
;; This program is distributed in the hope that it will be useful,
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
;; General Public License for more details.
|
|
;;
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with this program; see the file COPYING. If not, write to
|
|
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
;; Floor, Boston, MA 02110-1301, USA.
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Code:
|
|
|
|
(require 'xml)
|
|
(require 'identica-mode)
|
|
|
|
; ____________________
|
|
;
|
|
; Variables
|
|
; ____________________
|
|
|
|
|
|
(defvar identica-friends-buffer nil
|
|
"Friend's Buffer. Internal use of identica-friends.el."
|
|
)
|
|
|
|
(defvar identica-friends-buffer-name "*identica-friends*"
|
|
"Friends buffer's name. Changing this variable will effect after you
|
|
recall identica-friends functions.
|
|
Be aware of no function or actual buffers exists. Reboot all identica-friends functions."
|
|
)
|
|
|
|
(defvar identica-friends-buffer-type nil
|
|
"If the buffer contains a list of users, the this is setted into 'users.
|
|
If the buffer contains a list of groups, this is setted into 'groups.
|
|
Nil means, no buffer or just the programmer forgot to set it! :-S ."
|
|
)
|
|
|
|
; ----
|
|
; Hooks Variables
|
|
; ----
|
|
|
|
(defcustom identica-friends-good-bye-hooks
|
|
'nil
|
|
"These functions are called as soon as the `identica-friends-good-bye' functions finnish."
|
|
:type '(hook)
|
|
)
|
|
|
|
|
|
(defcustom identica-friends-mode-hooks
|
|
'nil
|
|
"These functions are called as soon as the `identica-friends-mode' functions finnish."
|
|
:type '(hook)
|
|
)
|
|
|
|
|
|
(defcustom identica-friends-show-friends-hooks
|
|
'nil
|
|
"These functions are called as soon as the `identica-show-friends' functions finnish."
|
|
:type '(hook)
|
|
)
|
|
|
|
(defcustom identica-friends-show-followers-hooks
|
|
'nil
|
|
"These functions are called as soon as the `identica-show-followers' functions finnish."
|
|
:type '(hook)
|
|
)
|
|
|
|
(defcustom identica-friends-next-user-hooks
|
|
'nil
|
|
"These functions are called as soon as the `identica-friends-next-user' functions finnish."
|
|
:type '(hook)
|
|
)
|
|
|
|
(defcustom identica-friends-prev-user-hooks
|
|
'nil
|
|
"These functions are called as soon as the `identica-friends-prev-user' functions finnish."
|
|
:type '(hook)
|
|
)
|
|
|
|
|
|
|
|
|
|
; ____________________
|
|
;
|
|
; Faces and font-lock
|
|
; ____________________
|
|
|
|
(defface identica-friends-mode-id
|
|
'(
|
|
; If there's dark background...
|
|
(((class color) (background dark))
|
|
:foreground "yellow"
|
|
)
|
|
; If there's light background...
|
|
(((class color) (background light))
|
|
:foreground "red"
|
|
)
|
|
|
|
(t :background "white"
|
|
:foreground "blue")
|
|
)
|
|
""
|
|
)
|
|
|
|
(defface identica-friends-mode-bar
|
|
'(
|
|
; If there's dark background...
|
|
(((class color) (background dark))
|
|
:bold t
|
|
)
|
|
; If there's light background...
|
|
(((class color) (background light))
|
|
:bold t
|
|
)
|
|
|
|
(t :background "white"
|
|
:foreground "blue"
|
|
:bold t)
|
|
)
|
|
""
|
|
)
|
|
|
|
(defvar identica-friends-mode-font-lock
|
|
'(
|
|
;; font-lock-keywords
|
|
(
|
|
("^Id: .*$" . 'identica-friends-mode-id)
|
|
("^Nick: .*$" . 'identica-username-face)
|
|
("^--------------------$" . 'identica-friends-mode-bar)
|
|
)
|
|
|
|
;; Otros...
|
|
)
|
|
;;
|
|
"Font lock for `identica-friends--mode'"
|
|
)
|
|
|
|
; ____________________
|
|
;
|
|
; Keymaps
|
|
; ____________________
|
|
|
|
;; Keymaps calls functions from the "Interactive API Commands" sections(see below).
|
|
|
|
(defvar identica-friends-mode-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(define-key map "q" 'identica-friends-good-bye)
|
|
(define-key map "n" 'identica-friends-next-user)
|
|
(define-key map "p" 'identica-friends-prev-user)
|
|
(define-key map [down] 'identica-friends-next-user)
|
|
(define-key map [up] 'identica-friends-prev-user)
|
|
(define-key map [left] 'identica-friends-prev-user)
|
|
(define-key map [right] 'identica-friends-next-user)
|
|
(define-key map [return] 'identica-friends-goto-timeline-at-point)
|
|
map)
|
|
"Keymap for `identica-friends-mode'."
|
|
)
|
|
|
|
|
|
; ____________________
|
|
;
|
|
; Major Mode
|
|
; ____________________
|
|
|
|
|
|
(define-derived-mode identica-friends-mode nil "Identica-friends-mode"
|
|
"Major mode for identica-friends buffer.
|
|
Use `identica-show-friends' to call this buffer."
|
|
;; font lock para ej-mode
|
|
(set (make-local-variable 'font-lock-defaults)
|
|
identica-friends-mode-font-lock)
|
|
(set (make-local-variable 'buffer-read-only) t)
|
|
(make-local-variable 'inhibit-read-only)
|
|
(run-hooks 'identica-friends-mode-hooks)
|
|
)
|
|
|
|
|
|
; ________________________________________
|
|
;
|
|
; Interactive API Commands
|
|
; ________________________________________
|
|
|
|
|
|
(defun identica-friends-good-bye ()
|
|
"Bury the *identica-friends* buffer"
|
|
(interactive)
|
|
(with-current-buffer identica-friends-buffer
|
|
(bury-buffer)
|
|
(run-hooks 'identica-friends-good-bye-hooks)
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-next-user ()
|
|
"Put the pointer in the next friend or follower in the identica-friend buffer."
|
|
(interactive)
|
|
(with-current-buffer identica-friends-buffer
|
|
(goto-char (identica-friends-find-next-user-position))
|
|
)
|
|
(run-hooks 'identica-friends-next-user-hooks)
|
|
)
|
|
|
|
(defun identica-friends-prev-user ()
|
|
"Put the pointer in the previous friend or follower in the identica-friend buffer."
|
|
(interactive)
|
|
(with-current-buffer identica-friends-buffer
|
|
(goto-char (identica-friends-find-prev-user-position))
|
|
)
|
|
(run-hooks 'identica-friends-prev-user-hooks)
|
|
)
|
|
|
|
(defun identica-friends-goto-timeline-at-point ()
|
|
"Check whenever we are in user-list or group-list. If we are listing user, call `identica-friends-goto-user-timeline-at-point',
|
|
if not call `identica-friends-goto-group-timeline-at-point'."
|
|
(interactive)
|
|
(cond
|
|
((eq identica-friends-buffer-type 'users)
|
|
(identica-friends-goto-user-timeline-at-point)
|
|
)
|
|
((eq identica-friends-buffer-type 'groups)
|
|
(identica-friends-goto-group-timeline-at-point)
|
|
)
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-goto-user-timeline-at-point ()
|
|
"Search for the username and go to his timeline."
|
|
(interactive)
|
|
(let ((username (identica-friends-find-username))
|
|
)
|
|
(identica-user-timeline username)
|
|
(switch-to-buffer identica-buffer)
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-goto-group-timeline-at-point ()
|
|
"Search for the group name and go to his timeline."
|
|
(interactive)
|
|
;; Look that `identica-friends-find-username' can be used for getting anything that starts with the "Nick: " string,
|
|
;; so is usefull here as well!
|
|
(let ((groupname (identica-friends-find-username))
|
|
)
|
|
(identica-group-timeline groupname)
|
|
(switch-to-buffer identica-buffer)
|
|
)
|
|
)
|
|
;
|
|
; Main function:
|
|
; Followers Commands
|
|
;
|
|
|
|
|
|
(defun identica-show-followers()
|
|
(interactive)
|
|
(setq identica-friends-buffer-type 'users)
|
|
(identica-http-get (sn-account-server sn-current-account)
|
|
(sn-account-auth-mode sn-current-account)
|
|
"statuses" "followers" nil 'identica-friends-show-user-sentinel '("follower"))
|
|
(run-hooks 'identica-friends-show-followers-hooks)
|
|
)
|
|
|
|
|
|
;
|
|
; Main function:
|
|
; Friends Commands
|
|
;
|
|
|
|
|
|
(defun identica-show-friends ()
|
|
(interactive)
|
|
; (setq identica-method-class "statuses")
|
|
; (setq identica-method "friends")
|
|
; (identica-http-get identica-method-class identica-method identica-show-friend-sentinel)
|
|
(setq identica-friends-buffer-type 'users)
|
|
(identica-http-get (sn-account-server sn-current-account) ;; server
|
|
(sn-account-auth-mode sn-current-account);; auth-mode
|
|
"statuses" "friends" nil 'identica-friends-show-user-sentinel '("friend"))
|
|
(run-hooks 'identica-friends-show-friends-hooks)
|
|
)
|
|
|
|
(defun identica-show-groups ()
|
|
(interactive)
|
|
;; (setq identica-method-class "statuses")
|
|
;; (setq identica-method "friends")
|
|
;; (identica-http-get identica-method-class identica-method identica-show-friend-sentinel)
|
|
(setq identica-friends-buffer-type 'groups)
|
|
(identica-http-get (sn-account-server sn-current-account) ;; server
|
|
(sn-account-auth-mode sn-current-account);; auth-mode
|
|
"statusnet" "groups/list" nil 'identica-friends-show-user-sentinel '("group"))
|
|
;;(run-hooks 'identica-friends-show-groups-hooks)
|
|
)
|
|
|
|
|
|
; ____________________
|
|
;
|
|
; Auxiliary Functions
|
|
; ____________________
|
|
|
|
|
|
(defun identica-friends-find-username ()
|
|
"Find the username in the nearby at current position.
|
|
|
|
I suppose that the cursor is on the nickname and not anywhere."
|
|
(save-excursion
|
|
(if (search-forward-regexp "Nick: \\(.*\\)" nil t)
|
|
(match-string-no-properties 1)
|
|
nil
|
|
)
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-buffer ()
|
|
"Show a new buffer with all the friends. "
|
|
(setq identica-friends-buffer (get-buffer-create identica-friends-buffer-name))
|
|
(switch-to-buffer identica-friends-buffer)
|
|
(identica-friends-mode)
|
|
)
|
|
|
|
|
|
(defun identica-friends-get-current-user ()
|
|
"Return the current user(friend or follower) that we are pointing now in the *identica-buffer*.
|
|
This will be returned as a list wich components are in these order:
|
|
(NICK NAME DESCRIPTION LOCATION)"
|
|
|
|
(setq usr '())
|
|
(save-excursion
|
|
;; Position at the beginning of the user.
|
|
(search-backward-regexp "^--------------------$" nil t)
|
|
(goto-char (match-beginning 0))
|
|
|
|
(setq usr (cons (identica-friends-get-location) usr))
|
|
(setq usr (cons (identica-friends-get-desc) usr))
|
|
|
|
(setq usr (cons (identica-friends-get-name) usr))
|
|
(setq usr (cons (identica-friends-get-nick) usr))
|
|
)
|
|
usr
|
|
)
|
|
|
|
(defun identica-friends-get-nick ()
|
|
"Get the *next* user(friend or follower) nick.
|
|
If there are no user, return nil."
|
|
(with-current-buffer identica-friends-buffer
|
|
(save-excursion
|
|
(search-forward-regexp "Nick: \\(.*\\)$" nil t)
|
|
(match-string-no-properties 1)
|
|
)
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-get-name ()
|
|
"Get the *next* user(friend or follower) nick.
|
|
If there are no user, return nil."
|
|
(with-current-buffer identica-friends-buffer
|
|
(save-excursion
|
|
(search-forward-regexp "Name: \\(.*\\)$" nil t)
|
|
(match-string-no-properties 1)
|
|
)
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-get-desc ()
|
|
"Get the current user(friend or follower) nick.
|
|
If there are no user, return nil."
|
|
(with-current-buffer identica-friends-buffer
|
|
(save-excursion
|
|
(search-forward-regexp "Description: \\(.*\\)$" nil t)
|
|
(match-string-no-properties 1)
|
|
)
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-get-location ()
|
|
"Get the current user(friend or follower) nick.
|
|
If there are no user, return nil."
|
|
(with-current-buffer identica-friends-buffer
|
|
(save-excursion
|
|
(search-forward-regexp "Location: \\(.*\\)$" nil t)
|
|
(match-string-no-properties 1)
|
|
)
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-show-user-sentinel
|
|
(&optional status method-class method parameters type-of-user)
|
|
"Sentinel executed after recieving all the information from identi.ca.
|
|
This sentinel needs to know if the TYPE-OF-USER(or type of list) is one of these:
|
|
- \"friend\"
|
|
- \"follower\"
|
|
- \"group\"
|
|
|
|
First, its parse the XML file recieved by identi.ca. While parsing, it show the user data into a buffer.
|
|
|
|
"
|
|
;; cnngimenez: This I used for debug HTTP
|
|
(identica-friends-copiar-http-buffer)
|
|
;; Search for the begining of the xml...
|
|
(goto-char (point-min))
|
|
(search-forward "<?xml")
|
|
(setq start-xml (match-beginning 0))
|
|
;; Parse xml into a list
|
|
(setq lst-xml (xml-parse-region start-xml (point-max)))
|
|
;; Change buffer...
|
|
(identica-friends-buffer)
|
|
;; Find elements on that list and write it
|
|
(identica-friends-parse-xml-user-lists type-of-user lst-xml)
|
|
|
|
(goto-char (point-min))
|
|
)
|
|
|
|
|
|
|
|
(defun identica-friends-parse-xml-user-lists (type-of-user xml-lst)
|
|
"Parse the xml-lst list and, after that, write every user into the current buffer.
|
|
The way it is parsed depends on the type-of-user we are talking about:
|
|
- \"friend\"
|
|
- \"follower\"
|
|
- \"group\"
|
|
"
|
|
;; Get first element
|
|
(setq xml-lst (car xml-lst))
|
|
;; ignore the word 'users' and the next element... remove enter.
|
|
(setq xml-lst (nthcdr 3 xml-lst))
|
|
;; Erase friends-buffer
|
|
(with-current-buffer identica-friends-buffer-name
|
|
(let ((inhibit-read-only t))
|
|
(delete-region (point-min) (point-max))
|
|
)
|
|
)
|
|
;; for each user in the xml list, parse it, and write it...
|
|
(dolist (usr xml-lst)
|
|
(unless (stringp usr)
|
|
(cond ((string= type-of-user "friend")
|
|
(identica-friends-write-user
|
|
(identica-friends-get-friend-data usr))) ;; Is a friend, parse xml as a friends.xml
|
|
((string= type-of-user "follower")
|
|
(identica-friends-write-user
|
|
(identica-friends-get-follower-data usr)));; is a follower, parse as followers.xml
|
|
((string= type-of-user "group")
|
|
(identica-friends-write-group
|
|
(identica-friends-get-group-data usr)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
|
|
|
|
(defun identica-friends-write-user (usr-data)
|
|
"Write an user taking the info from a list.
|
|
The list must be of the form given by the functions `identica-friends-get-friend-data'
|
|
or `identica-friends-get-follower-data':
|
|
|
|
(id . name . screen_name . location . description )
|
|
|
|
"
|
|
(let ((inhibit-read-only t))
|
|
(insert-and-inherit "\nNick: " (decode-coding-string (nth 2 usr-data) 'utf-8))
|
|
(insert-and-inherit "\nName: " (decode-coding-string (nth 1 usr-data) 'utf-8))
|
|
(insert-and-inherit "\nDescription: " (decode-coding-string (nth 4 usr-data) 'utf-8))
|
|
(insert-and-inherit "\nLocation: " (decode-coding-string (nth 3 usr-data) 'utf-8))
|
|
(insert-and-inherit "\n--------------------\n")
|
|
)
|
|
)
|
|
|
|
(defun identica-friends-write-group (group-data)
|
|
"Write a group taking the info from a list.
|
|
The list must be of the form given by the functions `identica-friends-get-group-data':
|
|
|
|
(id url nickname fullname membership blocked member_count logo homepage description location modified)"
|
|
(let ((inhibit-read-only t))
|
|
(insert-and-inherit "\nNick: " (decode-coding-string (nth 2 group-data) 'utf-8))
|
|
(insert-and-inherit "\nName: " (decode-coding-string (nth 3 group-data) 'utf-8))
|
|
(insert-and-inherit "\nURL: " (decode-coding-string (nth 1 group-data) 'utf-8))
|
|
(insert-and-inherit "\nDescription: " (decode-coding-string (nth 9 group-data) 'utf-8))
|
|
(insert-and-inherit "\nLocation: " (decode-coding-string (nth 10 group-data) 'utf-8))
|
|
(insert-and-inherit "\nHomepage: " (decode-coding-string (nth 8 group-data) 'utf-8))
|
|
(insert-and-inherit "\n--------------------\n")
|
|
)
|
|
)
|
|
|
|
;; *****
|
|
;; ** Comment about `identica-friends-get-follower-data' and `identica-friends-get-friend-data':
|
|
;;
|
|
;; These parsers must be changed to a most suitable way of finding the members.
|
|
;; Maybe using the "member" function or any simmilar makes a more reliable way of finding the attributes
|
|
;; than going to the nth element of the list.
|
|
;;
|
|
;; This is because if we change the structure of the XML, or just alternate some items(for example: instead
|
|
;; using the description before the location, in the future the description comes after the location) this
|
|
;; functions won't work properly. Also, they aren't readable and easy to change.
|
|
;;
|
|
;; *****
|
|
|
|
(defun identica-friends-get-follower-data (usr-lst)
|
|
"Parse the list and make a more easy-to-read list. The final list will have the following form suitable
|
|
for writing in a buffer with the function `identica-friends-write-user'.
|
|
(id . name . screen_name . location . description )."
|
|
|
|
(setq lst '())
|
|
|
|
;; Put the desription
|
|
(push
|
|
(nth 2 (nth 11 usr-lst))
|
|
lst
|
|
)
|
|
|
|
;; Put the location
|
|
(push
|
|
(nth 2 (nth 9 usr-lst))
|
|
lst
|
|
)
|
|
|
|
;; Put the screen-name
|
|
(push
|
|
(nth 2 (nth 7 usr-lst))
|
|
lst)
|
|
|
|
;; Put the name
|
|
(push
|
|
(nth 2 (nth 5 usr-lst))
|
|
lst)
|
|
|
|
;; Put the id
|
|
(push
|
|
(nth 2 (nth 3 usr-lst))
|
|
lst)
|
|
|
|
|
|
;; Replace nils into strings...
|
|
(replace-nils lst "")
|
|
)
|
|
|
|
|
|
(defun identica-friends-get-friend-data (usr-lst)
|
|
"Parse the list and make a list more easy to read. The list has the following form:
|
|
(id . name . screen_name . location . description ).
|
|
|
|
This form is suitable for the function `identica-friends-write-user'.
|
|
"
|
|
|
|
(setq lst '())
|
|
|
|
;; Put the desription
|
|
(push
|
|
(nth 2 (nth 11 usr-lst))
|
|
lst
|
|
)
|
|
|
|
;; Put the location
|
|
(push
|
|
(nth 2 (nth 9 usr-lst))
|
|
lst
|
|
)
|
|
|
|
;; Put the screen name
|
|
(push
|
|
(nth 2 (nth 7 usr-lst))
|
|
lst
|
|
)
|
|
|
|
|
|
;; Put the name
|
|
(push
|
|
(nth 2 (nth 5 usr-lst))
|
|
lst
|
|
)
|
|
|
|
|
|
;; Put the id
|
|
(push
|
|
(nth 2 (nth 3 usr-lst))
|
|
lst
|
|
)
|
|
|
|
;; Replace nils into strings...
|
|
(replace-nils lst "")
|
|
)
|
|
|
|
(defun identica-friends-get-group-data (usr-lst)
|
|
"Parse the list and make a more easy-to-read list. The final list will have the following form suitable
|
|
for writing in a buffer with the function `identica-friends-write-user'.
|
|
|
|
(id url nickname fullname membership blocked member_count logo homepage description location modified)."
|
|
|
|
(setq lst '())
|
|
|
|
;; Put the id
|
|
(push
|
|
(nth 2 (nth 3 usr-lst))
|
|
lst
|
|
)
|
|
|
|
;; Put the url
|
|
(push
|
|
(nth 2 (nth 5 usr-lst))
|
|
lst
|
|
)
|
|
|
|
;; Put the nickname
|
|
(push
|
|
(nth 2 (nth 7 usr-lst))
|
|
lst)
|
|
|
|
;; Put the fullname
|
|
(push
|
|
(nth 2 (nth 9 usr-lst))
|
|
lst)
|
|
|
|
;; Put the membership
|
|
(push
|
|
(nth 2 (nth 11 usr-lst))
|
|
lst)
|
|
|
|
;; Put the blocked
|
|
(push
|
|
(nth 2 (nth 13 usr-lst))
|
|
lst)
|
|
|
|
;; Put the member-count
|
|
(push
|
|
(nth 2 (nth 15 usr-lst))
|
|
lst)
|
|
|
|
;; Put the logo(original logo!)
|
|
(push
|
|
(nth 2 (nth 17 usr-lst))
|
|
lst)
|
|
|
|
;; Put the homepage
|
|
(push
|
|
(nth 2 (nth 25 usr-lst))
|
|
lst)
|
|
|
|
;; Put the description
|
|
(push
|
|
(nth 2 (nth 27 usr-lst))
|
|
lst)
|
|
|
|
;; Put the location
|
|
(push
|
|
(nth 2 (nth 29 usr-lst))
|
|
lst)
|
|
|
|
;; Put the modified
|
|
(push
|
|
(nth 2 (nth 33 usr-lst))
|
|
lst)
|
|
|
|
(setq lst (reverse lst))
|
|
|
|
;; Replace nils into strings...
|
|
(replace-nils lst "")
|
|
)
|
|
|
|
|
|
(defun identica-friends-find-next-user-position ()
|
|
"Find the position in the *identica-friend-buffer* of the next user. If there are no next user(we are at the end of the list)
|
|
return the first one.
|
|
This function return nil when there are any friend in the buffer."
|
|
(with-current-buffer identica-friends-buffer
|
|
;; We have to put one char forward so, we cannot detect the actual "Nick: "
|
|
(forward-char 1)
|
|
(if (search-forward-regexp "Nick: " nil t)
|
|
(match-beginning 0)
|
|
(progn
|
|
;; Not found! Maybe we are at the end?
|
|
;; Go to the beginning of the buffer and search again, if fails, this user has no friends!
|
|
(goto-char (point-min))
|
|
(if (search-forward-regexp "Nick: " nil t)
|
|
(match-beginning 0) ; Yes, he has friends... the pointer was at the end of buffer
|
|
'nil ; Wow... he has no friends!
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(defun identica-friends-find-prev-user-position ()
|
|
"Find the position in the *identica-friend-buffer* of the previous user. If there are no previous user(we are at the begin of the list)
|
|
return the last one.
|
|
This function return nil when there are any friend in the buffer."
|
|
(with-current-buffer identica-friends-buffer
|
|
(if (search-backward-regexp "Nick: " nil t)
|
|
(match-beginning 0)
|
|
(progn
|
|
;; Not found! Maybe we are at the end?
|
|
;; Go to the beginning of the buffer and search again, if fails, this user has no friends!
|
|
(goto-char (point-max))
|
|
(if (search-backward-regexp "Nick: " nil t)
|
|
(match-beginning 0) ; Yes, he has friends... the pointer was at the end of buffer
|
|
'nil ; Wow... he has no friends!
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
; ____________________
|
|
;
|
|
; Commons Functions
|
|
; ____________________
|
|
|
|
|
|
;; Are there any function to replace anything from a list?
|
|
(defun replace-nils (lst elt)
|
|
"Replace nils with an element elt."
|
|
(unless (null lst)
|
|
(if (null (car lst))
|
|
(cons elt (replace-nils (cdr lst) elt))
|
|
(cons (car lst) (replace-nils (cdr lst) elt))
|
|
)
|
|
)
|
|
)
|
|
|
|
|
|
|
|
|
|
;
|
|
; For debugging purpose
|
|
;
|
|
|
|
|
|
|
|
(defvar identica-friends-http-debug "*identica-http*"
|
|
"Buffer to the http requests")
|
|
|
|
(defun identica-friends-copiar-http-buffer ()
|
|
"Copia el buffer http a otro nuevo para ver el resultado de la comunicación."
|
|
(with-current-buffer identica-http-buffer
|
|
(setq str (buffer-string))
|
|
)
|
|
(with-current-buffer (get-buffer-create identica-friends-http-debug)
|
|
(delete-region (point-min) (point-max))
|
|
(insert str)
|
|
)
|
|
)
|
|
|
|
|
|
(provide 'identica-friends)
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;; friends.el ends here
|