#!ruby -Ku
require 'rexml/document'
require 'time'

class Timelog4r

=begin rdoc
Description::
  Customized XML Parser for TimelogAPI.

=end
  module XML_Parser

=begin rdoc
Description::
  memo's entry permission to symbol.

Params::
  :string memo's permission [String]

Return::

  :public (case of 'public permission')
  :friends_only (case of 'friends-only permission')
  :private (case of 'private permission')
  :unknown (other case)

=end
    def permission_to_sym(string)
      case string
        when '0'
          return :public
        when '1'
          return :friends_only
        when '2'
          return :private
        else
          return :unknown
      end
    end

=begin rdoc
Description::
  tag-strings convert to Array in tag.

Params::
  :tag_string tags [String]

Return::
  ['TagA', 'TagB', ...]

=end
    def tags_to_a(tag_string)
      return tag_string.chop.split(',')
    end

=begin rdoc
Description::
  parse XML::Element convert to hash.

Params::
  :element entry-element [REXML::Element]

Return::
  {:memo_text => '...', ...}

RelatedMethods::
  permission_to_sym
  parse_author
  tags_to_a

=end
    def parse_entry(element)
      result = {
        :memo_text => element.elements['memo'].text,
        :memo_id => element.elements['id'].text,
        :permission =>
           permission_to_sym(
             element.elements['dispflag'].text
           ),
        :modified =>
           Time.parse(
             element.elements['modified'].text
           ),
        :permalink =>
           URI.parse(
             element.elements['link'].attributes['href']
           ),
        :author =>
           parse_author(
             element.elements['author']
           )
      }
      result[:reply_to] = {
        :memo_id =>
          element.elements['replyid'].text,
        :author => {
          :user_id =>
            element.elements['toid'].text,
          :screen_name =>
            element.elements['toname'].text,
        }
      } if element.elements['toid'].has_text?
      if element.elements['tododate'].has_text? then
        result[:todo] = Time.parse(
          element.elements['tododate'].text
        ) unless element.elements['tododate'].text.eql?(' ')
      end
      if element.elements['tag'].has_text? then
        result[:tag] = tags_to_a(element.elements['tag'].text)
      end
      if element.elements['fromid'] then
        result[:in_group] = {
          :user_id =>
            element.elements['fromid'].text,
          :screen_name =>
            element.elements['fromname'].text
        }
      end
      return result
    end

=begin rdoc
Description::
  parse XML-Element convert to hash

Params::
  :element author-element [REXML::Element]

Return::
  {:images => {:normal => ...}, ...}

=end
    def parse_author(element)
      return nil unless element.elements['id'].has_text?
      result = {
        :images => {
          :normal =>
            URI.parse(
              element.elements['image/normal'].text
            ),
          :thumbnail =>
            URI.parse(
              element.elements['image/thumb'].text
            ),
          :small =>
            URI.parse(
              element.elements['image/small'].text
            )
        }
      }
      if element.elements['statflag'] then
        author_type = element.elements['statflag'].text == '2' ?
        'group' : 'user'
        result[:type] = author_type.to_sym
        result["#{author_type}_id".to_sym] = element.elements['id'].text
        result["#{author_type}_name".to_sym] = element.elements['name'].text
      end
      return result
    end

=begin rdoc
Description::
  parse XML-Document convert to hash.

Params::
  :document timeline document [REXML::Document]

Return::
  {:title => 'Timelog ...', :entries => [...]}

RelatedMethods::
  parse_author
  parse_entry

=end
    def parse_timeline(document)
      result = {
        :title =>
          document.elements['memos/title'].text,
        :link =>
          URI.parse(
            document.elements['memos/link'].attributes['href']
          ),
        :modified =>
          Time.parse(
            document.elements['memos/modified'].text
          )
      }
      author = parse_author(document.elements['memos/author'])
      result[:author] = author if author
      result[:entries] = document.elements.collect('memos/entry'){|entry|
        parse_entry(entry)
      }
      return result
    end

=begin rdoc
Description::
  parse XML-Element convert to hash.

Params::
  :element tag-element [REXML::Element]

Return::
  {:tag => 'tag', :count => 2}

=end
    def parse_tag(element)
      {
        :tag =>
          element.elements['tag'].text,
        :count =>
          element.elements['cnt'].text
      }
    end

=begin rdoc
Description::
  parse XML-Document convert to hash.

Params::
  :document tags-document [REXML::Document]

Return::
  {:title => 'Timelog ... ', :entries => [...]}

RelatedMethods::
  parse_tag

=end
    def parse_tag_list(document)
      result = {
        :title =>
          document.elements['tags/title'].text,
        :link =>
          URI.parse(document.elements['tags/link'].attributes['href']),
        :modified =>
          Time.parse(document.elements['tags/modified'].text)
      }
      result[:tags] = document.elements.collect('tags/tagdata'){|tag|
        parse_tag(tag)
      }
      return result
    end

=begin rdoc
Description::
  parse XML-Element convert to hash.

Params::
  :element user-element [REXML::Element]

Return::
  {:user_id => 'user_id', :user_name => 'name', ...}

=end
    def parse_user(element)
      {
        :user_id =>
          element.elements['id'].text,
        :user_name =>
          element.elements['name'].text,
        :images => {
          :normal =>
            URI.parse(
              element.elements['image/normal'].text
            ),
          :thumbnail =>
            URI.parse(
              element.elements['image/thumb'].text
            ),
          :small =>
            URI.parse(
              element.elements['image/small'].text
            )
        }
      }
    end

=begin rdoc
Description::
  parse XML-Document convert to hash.

Params::
  :document users-document [REXML::Document]

Return::
  {:title => 'Timelog ... ', :entries => [...]}

RelatedMethods::
  parse_user

=end
    def parse_user_list(document)
      result = {
        :title =>
          document.elements['friends/title'].text,
        :link =>
          URI.parse(
            document.elements['friends/link'].attributes['href']
          ),
        :modified =>
          Time.parse(
            document.elements['friends/modified'].text
          )
      }
      result[:entries] = document.elements.collect('friends/entry'){|friend|
        parse_user(friend)
      }
      return result
    end

=begin rdoc
Description::
  parse XML-Document convert to hash.

Params::
  :document profile-document [REXML::Document]

Return::
  {:title => 'Timelog ... ', :link => ...}

RelatedMethods::
  parse_user
  tags_to_a

=end
    def parse_profile(document)
      result = {
        :title =>
          document.elements['show/title'].text,
        :link =>
          URI.parse(
            document.elements['show/link'].attributes['href']
          ),
        :modified =>
          Time.parse(
            document.elements['show/modified'].text
          ),
        :user => {
          :parmalink =>
             URI.parse(
               document.elements['show/user/url'].text
             ),
          :use_tags =>
            tags_to_a(
              document.elements['show/user/tags'].text
            )
        }.merge(
          parse_user(document.elements['show/user'])
        )
      }
      if document.elements['show/user/prof_url'].has_text?
        result[:user][:other_site] = URI.parse(
          document.elements['show/user/prof_url'].text
        )
      end
      if document.elements['show/user/prof_url'].has_text?
        result[:user][:profile_message] = document.elements['show/user/prof_msg'].text
      end
      return result
    end
  end
end