blogmarks 0.1.0

data/CHANGES

@@ -0,0 +1,7 @@
+= BlogMarks Changelog
+
+== Version 0.1.0
+
+Initial version release.
+
+* This first version let you search public/private marks

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Jonathan Tron
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,44 @@
+= Project: Builder
+
+== Goal
+
+Provide a simple way to interact with BlogMarks.net online bookmarking system.
+
+== Classes
+
+BlogMarks::Client:: Client to interact with BlogMarks.net API
+BlogMarks::Tag:: Define a Tag 
+BlogMarks::Mark:: Define a Mark 
+BlogMarks::Feed:: Define a Feed 
+
+== Usage
+  
+  # Accessing last blogmarks :
+  client = BlogMarks::Client.new('username', 'mypassword')
+  client.find_marks # Without other options, the api will return the last 30 marks (subject to change)
+  # then get the default feed and iterate over fetched mark
+  client.feed.marks.each do |mark|
+    puts "Mark Link : " + mark.link_related
+    puts "Mark Summary : " + mark.summary
+  end
+
+or
+
+  # Accessing YOUR last blogmarks :
+  client = BlogMarks::Client.new('username', 'mypassword')
+  client.find_my_marks # Without other options, the api will return your last 30 marks (subject to change)
+
+or
+
+  # Accessing only the 10 latest blogmarks
+  client = BlogMarks::Client.new('username', 'mypassword')
+  client.find_marks( :last => 10 )
+
+TODO : Show some example to post/update/edit blogmarks and tags
+
+== Contact
+
+Author::     Jonathan Tron
+Email::      jonathan@tron.name
+Home Page::  http://projects.tron.name/ruby/blogmarks/
+License::    MIT Licence (http://www.opensource.org/licenses/mit-license.html)

data/lib/blogmarks.rb

@@ -0,0 +1,29 @@
+#/bin/env ruby
+#--
+# Copyright (c) 2004 Jonathan Tron
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require File.dirname(__FILE__) + '/blogmarks/class_attribute_accessors'
+require File.dirname(__FILE__) + '/blogmarks/feed'
+require File.dirname(__FILE__) + '/blogmarks/tag'
+require File.dirname(__FILE__) + '/blogmarks/mark'
+require File.dirname(__FILE__) + '/blogmarks/client'

data/lib/blogmarks/class_attribute_accessors.rb

@@ -0,0 +1,67 @@
+#--
+# Copyright (c) 2005 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/blogmarks/client.rb

@@ -0,0 +1,301 @@
+#/bin/env ruby
+#--
+# Copyright (c) 2004 Jonathan Tron
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+# Standard ruby libs
+require 'uri'
+require 'net/http'
+require 'base64'
+require 'digest/md5'
+require 'digest/sha1'
+require 'rexml/document'
+
+# Gem dependencies
+require 'rubygems'
+require 'builder'
+
+# Inner dependencies
+require File.dirname(__FILE__) + '/feed'
+
+module BlogMarks
+
+  class Client
+    # API URL to interact with BlogMarks.net
+    cattr_accessor  :api_url
+    @@api_url      = 'http://api.blogmarks.net'
+    # User agent to report to blogmarks server
+    cattr_reader    :user_agent
+    @@user_agent   = 'Ruby BlogmarksClient Library'
+    # Text used to compute the nonce for authentication 
+    cattr_accessor  :private_text
+    @@private_text = 'Ipsum Dolor Sit Amet'
+    
+    # Store the fetched Feed
+    attr_reader   :feed
+    # User login 
+    attr_accessor :user
+    # User password 
+    attr_accessor :password
+    
+    # Blogmarks client constructor
+    def initialize( user, password)
+      @user     = user
+      @password = password
+      @feed     = nil
+    end
+
+    # Add a Mark
+    def add_mark( mark )
+  
+    end
+
+    # Update a Mark
+    def update_mark( mark )
+  
+    end
+
+    # Delete a Mark
+    def delete_mark( mark )
+  
+    end
+
+    # Find some marks in public marks
+    #  
+    # This function accept an options hash, where options can be :
+    # 
+    # * <tt>:last</tt> <i>integer from -1 to ...</i>
+    #     Limit number of results (default: 30)
+    # * <tt>:offset</tt> <i>positive integer</i>
+    #     First result offset, for paging... (default: 0)
+    # * <tt>:search</tt> <i>string</i>
+    #     Searches for string in blogmarks (title, desc) + tags	
+    # * <tt>:tags</tt> <i>string</i>
+    #     Searches for requested public tags
+    # * <tt>:private_tags</tt> <i>string</i>
+    #     Recherche les blogmarks contenant les tags privés indiqués (*).
+    # * <tt>:related</tt> <i>regexp</i>
+    #     ???
+    # * <tt>:author</tt> <i>string <user></i>
+    #     Searches only in <user>'s marks
+    # * <tt>:private</tt> <i>true | false</i>
+    #     If true, also search in private marks	(default: false)
+    # * <tt>:month</tt> <i>integer 01 to 12</i>
+    #     if used with year, search only in marks posted durint that month	
+    # * <tt>:year</tt> <i>integer YYYY</i>
+    #     Restrict search to marks posted during that year	
+    # * <tt>:level</tt> <i>positive integer <level></i>
+    #     Restrict search to marks posted by at least <level> users	
+    # * <tt>:order_by</tt> <i>issued|modified|created|popularity</i>
+    #     Results sorting mode (default: issued)
+    # * <tt>:order_type</tt> <i>asc|desc</i>
+    #     Results dorting direction	(default: desc)
+    def find_marks( options={} )
+      url = build_url( "#{api_url}/marks", options )
+  
+      res = send_request(url)
+      
+      parse_xml_response(res)
+    end
+
+    # Find some marks in my marks
+    #
+    # This function is an alias to find_mark which set the :author option to current user in options hash.
+    # For accepted options see #find_marks
+    def find_my_marks( options={} )
+      options[:author] = @user
+      find_marks(options)
+    end
+
+    protected
+
+    def send_request( url, verb='GET', content=nil) #:nodoc:
+      nonce = get_nonce
+      creation_timestamp = Time.new.strftime("%Y-%m-%d\T%H:%M:%S\Z")
+      password_hash   = Digest::MD5.hexdigest(password)
+      password_digest = Base64.encode64(Digest::SHA1.hexdigest("#{nonce}#{creation_timestamp}#{password_hash}"))
+  
+      uri = URI.parse(url)
+      req = nil
+  
+      case verb
+        when 'POST'
+          req = Net::HTTP::Post.new(uri.request_uri)
+        when 'PUT'
+          req = Net::HTTP::Put.new(uri.request_uri)
+        when 'DELETE'
+          req = Net::HTTP::Delete.new(uri.request_uri)
+        else
+          req = Net::HTTP::Get.new(uri.request_uri)
+      end
+  
+      req['X-WSSE'] = "UsernameToken Username=\"#{user}\", PasswordDigest=\"#{password_digest}\", Nonce=\"#{nonce}\", Created=\"#{creation_timestamp}\""
+      req['User-Agent'] = user_agent 
+  
+      res = Net::HTTP.new( uri.host, uri.port ).start do | http |
+        http.request(req)
+      end
+  
+      case verb
+        when 'POST'
+          return true     if res.kind_of? Net::HTTPCreated
+        when 'PUT'
+          return true     if res.kind_of? Net::HTTPResetContent
+        when 'DELETE'
+          return true     if res.kind_of? Net::HTTPOK
+        when 'GET'
+          return res.body if res.kind_of? Net::HTTPOK
+      end
+      
+      # If reached we have an error
+      handle_error(res)
+    end
+
+    # Build an xml entry element to use during Mark post from params
+    #-- 
+    # TODO : Remove/Modify this method as we now pass a Mark Object to POST/DELETE/UPDATE method
+    #++
+    def params_to_xml( params={} ) #:nodoc:
+
+      return 'No Link'  if !params.has_key? :url
+      return 'No Title' if !params.has_key? :title
+  
+      buffer = ""
+      xm = Builder::XmlMarkup.new( :target => buffer )
+  
+      xm.instruct!
+  
+      xm.entry {
+    
+        xm.title(params[:title])
+    
+        xm.link( "rel" => "related", "href" => "#{params[:url]}")
+    
+        xm.summary( "#{params[:description]}" ) if params.has_key? :description
+    
+        xm.published( "0000-00-00" ) if params.has_key?(:private) && params[:private]
+
+        xm.published( Time.new.strftime("%Y-%m-%d\T%H:%M:%S\Z") ) if params.has_key?(:private) && !params[:private]
+          
+        params[:tags].each do |tag| 
+          xm.category( "term" => "#{api_url}/tags/", "sheme" => "#{tag}") if !tag.empty?
+        end if params.has_key? :tags
+    
+        params[:private_tags].each do |tag| 
+          xm.category( "term" => "#{api_url}/tags/user/#{user}/", "sheme" => "#{tag}") if !tag.empty?
+        end if params.has_key? :private_tags
+    
+        xm.link( "rel" => "via", "href" => "#{params[:via]}" ) if params.has_key? :via
+      }
+  
+      buffer
+    end
+
+    # Parse raw xml data and if successful build a Feed from it
+    def parse_xml_response( xml )  #:nodoc:
+      xml_doc = create_xml_document( xml )
+      
+      # If we successfuly build an REXML document, let's begin the work :)
+      if !xml_doc.nil?
+        @feed = BlogMarks::Feed.build_from_xml_element(xml_doc.root)
+      end
+    end
+
+    # Get a unique nonce to use for authentication
+    # As specified in API Spec,
+    # nonce is a string containing "timestamp SHA1(timestamp:private_text)"
+    def get_nonce
+      timestamp = Time.new.utc.strftime("%Y-%m-%d\T%H:%M:%S\Z")
+      temp = Digest::SHA1.hexdigest("#{timestamp}:#{private_text}")
+      return "#{timestamp} #{temp}"
+    end
+
+    # Build an URI with querystring based on params as in BlogMarks API Spec
+    #  * Multiple values for a param will be delimited by a space
+    #  * Multi-words values will be double-quoted
+    def build_url( ressource, params={} ) #:nodoc:
+      querystring = ""
+  
+      params.each do |index, param|
+        querystring << "&" unless querystring.empty?
+    
+        # Handle params composed of multiple value 
+        if param.kind_of? Array 
+          # Let's our query play nicely with tags composed of multiple word
+          param.collect! do |el| 
+            if el =~ /\s+/
+              "\"#{el}\""
+            else
+              el
+            end
+          end
+          param = param.join(' ')
+        end
+    
+        querystring << "#{index}=#{param}"
+      end
+  
+  
+      ressource << "?" << querystring if !querystring.empty?
+
+      return URI.escape(ressource)
+    end
+    
+    # Handle error when occurs
+    # Raise a simple message explaining error
+    #--
+    # TODO : add a simple subclass to base Exception with neat message access
+    #++
+    def handle_error( response_error )
+      message = ''
+      message = "HTTP authentication failed" if response_error.kind_of? Net::HTTPUnauthorized
+      message = "Requested URI does not reference a ressource or search returned no results." if response_error.kind_of? Net::HTTPNotFound
+      message = "Server-side error occured" if response_error.kind_of? Net::HTTPInternalServerError
+      
+      if response_error.kind_of? Net::HTTPInternalServerError
+        xml_doc = create_xml_document( response_error )
+        unless xml_doc.nil?
+          raise(message + "\n" + xml_doc.root.text)
+        end
+      end
+    end
+    
+    # Parse a string containing raw xml data and return its REXML::Document representation or nil if failed
+    def create_xml_document( xml )
+      xml_doc = nil
+      begin
+        begin
+          # Let's try to parse the xml
+          xml_doc = REXML::Document.new( xml, :ignore_whitespace_nodes => :all )
+        rescue Object
+          # If error occurs try to repair it with the htree
+          xml_doc = REXML::HTree.parse( xml ).to_rexml
+        end
+      rescue Object
+        xml_doc = nil
+      end
+      
+      return xml_doc
+    end
+  end
+
+end

data/lib/blogmarks/feed.rb

@@ -0,0 +1,98 @@
+#/bin/env ruby
+#--
+# Copyright (c) 2004 Jonathan Tron
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'uri'
+require 'rexml/document'
+require File.dirname(__FILE__) + '/mark'
+
+module BlogMarks
+  
+  class Feed
+    # Feed title
+    attr_reader   :title
+    # Blogmarks.net corresponding feed page
+    attr_reader   :link_alternate
+    # Previous Feed URI
+    attr_reader   :link_prev
+    # Next Feed URI
+    attr_reader   :link_next
+    # Feed update date
+    attr_reader   :updated
+    
+    # Feed Marks
+    attr_reader   :marks
+    
+    # Create a feed from params
+    #
+    # params hash can contains any of the object vars
+    def initialize( params={} )
+      @title          = params[:title]          || nil
+      @alternate      = params[:link_alternate] || nil
+      @link_prev      = params[:link_prev]      || nil
+      @link_next      = params[:link_next]      || nil
+      @updated        = params[:updated]        || nil
+      @marks          = params[:marks]          || []
+    end
+    
+    
+    class << self # Class methods
+      
+      # Parse an REXML::Element corresponding to the feed
+      def build_from_xml_element( feed )
+        # We need a valide REXML::Element parameters :D
+        return nil unless feed.kind_of?(REXML::Element)
+        
+        # Let's build the params to build a BlogMarks::Feed
+        params = {}
+        # Iterate over child nodes
+        feed.each_element do |element|
+          case element.name            
+            when 'head'
+              element.each_element do |headElement|
+                case headElement.name
+                  when 'title'
+                    params[:title]        = headElement.text
+                  when 'updated'
+                    params[:updated]      = Time.parse(headElement.text)
+                  when 'link'
+                    params[:link_alternate] = URI.parse( headElement.attributes['href'] ) if headElement.attributes['rel'] == 'alternate'
+                    params[:link_prev]      = URI.parse( headElement.attributes['href'] ) if headElement.attributes['rel'] == 'prev'
+                    params[:link_next]      = URI.parse( headElement.attributes['href'] ) if headElement.attributes['rel'] == 'next'
+                end
+              end
+              
+            when 'entry'
+              params[:marks]  = [] unless params.has_key?(:marks)
+              params[:marks]  <<  BlogMarks::Mark.build_from_xml_element(element)
+          end
+        end
+        
+        # Create and return a new Feed constructs using params hash
+        return Feed.new(params)
+      end
+      
+    end
+  end
+
+end

data/lib/blogmarks/mark.rb

@@ -0,0 +1,136 @@
+#/bin/env ruby
+#--
+# Copyright (c) 2004 Jonathan Tron
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'uri'
+require 'rexml/document'
+
+module BlogMarks
+
+  class Mark
+    # Mark Id 
+    attr_reader   :id
+    # Mark Title
+    attr_accessor :title
+    # Mark summary
+    attr_accessor :summary
+    # Mark's url
+    attr_accessor :link_related
+    # Mark's html representation
+    attr_reader   :link_alternate
+    # Mark's site screenshot
+    attr_reader   :link_image
+    # Mark's last update date
+    attr_reader   :updated
+    # Mark's published date
+    attr_accessor :published
+    # Mark's author
+    attr_accessor :author
+    # Mark's edit
+    attr_reader   :edit
+    # Mark's creation date
+    attr_accessor :bm_created
+    # Mark's public tags
+    attr_accessor :public_tags
+    # Mark's private tags
+    attr_accessor :private_tags
+    
+    # Create a mark from params
+    #
+    # params hash can contains any of the object vars, but :title and :link_related is mandatory
+    def initialize( params={} )
+      @id             = params[:id]             || nil
+      @title          = params[:title]          || raise( ArgumentError, ":title can't be empty")
+      @link_related   = params[:link_related]   || raise( ArgumentError, ":link_related can't be empty")
+      @link_alternate = params[:link_alternate] || nil
+      @link_image     = params[:link_image]     || nil
+      @summary        = params[:summary]        || nil
+      @updated        = params[:updated]        || nil
+      @published      = params[:published]      || nil
+      @author         = params[:author]         || nil
+      @edit           = params[:edit]           || nil
+      @bm_created     = params[:bm_created]     || nil
+      @public_tags    = params[:public_tags]    || []
+      @private_tags   = params[:private_tags]   || []
+    end
+    
+    
+    # Return an xml representation of the mark according to BlogMarks.net Specs
+    def to_xml
+      
+    end
+    
+    class << self # Class methods
+      
+      # Parse an REXML::Element corresponding to the entry
+      def build_from_xml_element( entry )
+        # We need a valide REXML::Element parameters :D
+        return nil unless entry.kind_of?(REXML::Element)
+        
+        # Let's build the params to build a BlogMarks::Mark
+        params = {}
+        
+        # Iterate over child nodes
+        entry.each_element do |element|
+          case element.name            
+            when 'id'
+              params[:id]           = element.text
+            when 'title'
+              params[:title]        = element.text
+            when 'updated'
+              params[:updated]      = Time.parse(element.text)
+            when 'published'
+              params[:published]    = Time.parse(element.text)
+            when 'author'
+              params[:author]       = element.elements['name'].text
+            when 'edit'
+              params[:edit]         = URI.parse(element.text)
+            when 'bm:created'
+              params[:bm_created]   = Time.parse(element.text)
+            when 'summary'
+              params[:summary]      = element.text
+            when 'link'
+              params[:link_related]   = URI.parse( element.attributes['href'] ) if element.attributes['rel'] == 'related'
+              params[:link_alernate]  = URI.parse( element.attributes['href'] ) if element.attributes['rel'] == 'alternate'
+              params[:link_image]     = URI.parse( element.attributes['href'] ) if element.attributes['rel'] == 'image'
+            when 'category'
+              if element.attributes['term'] == 'http://api.blogmarks.net/tags'
+                params[:public_tags] = [] unless params.has_key?(:public_tags)
+                params[:public_tags] << element.attributes['label'] 
+              end
+              
+              if element.attributes['term'] != 'http://api.blogmarks.net/tags'
+                params[:private_tags] = [] unless params.has_key?(:private_tags)
+                params[:private_tags] << element.attributes['label']
+              end
+          end
+        end
+        
+        # Create and return a new Mark constructs using params hash
+        return Mark.new(params)
+      end
+      
+    end
+  end
+
+end

data/lib/blogmarks/tag.rb

@@ -0,0 +1,106 @@
+#/bin/env ruby
+#--
+# Copyright (c) 2004 Jonathan Tron
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'uri'
+require 'rexml/document'
+
+module BlogMarks
+
+  class Tag
+    # Tag id 
+    attr_reader   :id
+    # Tag html representation uri
+    attr_reader   :link_alternate
+    # Tag image uri
+    attr_reader   :link_image
+    # Tag edit uri
+    attr_reader   :edit
+    # Tag title
+    attr_accessor :title
+    # Tag summary
+    attr_accessor :summary
+    # Tag publish date
+    attr_accessor :published
+    # Tag creation date
+    attr_reader   :bm_created
+    # Tag update date
+    attr_reader   :updated
+    
+    # Create a tag from params
+    #
+    # params hash can contains any of the object vars, but :title is mandatory
+    def initialize( params={} )
+      @id             = params[:id]             || nil
+      @title          = params[:title]          || raise( ArgumentError, ":title can't be empty")
+      @link_alternate = params[:link_alternate] || nil
+      @link_image     = params[:link_image]     || nil
+      @summary        = params[:summary]        || nil
+      @updated        = params[:updated]        || nil
+      @published      = params[:published]      || nil
+      @edit           = params[:edit]           || nil
+      @bm_created     = params[:bm_created]     || nil
+    end
+    
+    
+    class << self # Class methods
+      
+      # Parse an REXML::Element corresponding to the tag
+      def build_from_xml_element( tag )
+        # We need a valide REXML::Element parameters :D
+        return nil unless tag.kind_of?(REXML::Element)
+        
+        # Let's build the params to build a BlogMarks::Tag
+        params = {}
+        
+        # Iterate over child nodes
+        tag.each_element do |element|
+          case element.name            
+            when 'id'
+              params[:id]           = element.text
+            when 'title'
+              params[:title]        = element.text
+            when 'updated'
+              params[:updated]      = Time.parse(element.text)
+            when 'published'
+              params[:published]    = Time.parse(element.text)
+            when 'edit'
+              params[:edit]         = URI.parse(element.text)
+            when 'bm:created'
+              params[:bm_created]   = Time.parse(element.text)
+            when 'summary'
+              params[:summary]      = element.text
+            when 'link'
+              params[:link_alternate] = URI.parse( element.attributes['href'] ) if element.attributes['rel'] == 'alternate'
+              params[:link_image]     = URI.parse( element.attributes['href'] ) if element.attributes['rel'] == 'image'
+          end
+        end
+        
+        # Create and return a new Tag constructs using params hash
+        return Tag.new(params)
+      end
+      
+    end
+  end
+
+end

data/test/test_blogmarks_client.rb

@@ -0,0 +1,63 @@
+#/bin/env ruby
+#--
+# Copyright (c) 2004 Jonathan Tron
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'test/unit'
+require 'blogmarks'
+
+## This test should use a mock object to simulate the server response
+## I'm not too familiar with this so it will come later :(
+class TestClient < Test::Unit::TestCase
+
+  def setup
+    @client = BlogMarks::Client.new('', '')
+  end
+  
+  def test_create
+    assert_not_nil(@client)
+    assert_instance_of(BlogMarks::Client, @client)
+  end
+  
+  def test_find_marks
+    @client.find_marks
+    assert_not_nil(@client.feed)
+    assert(@client.feed.marks.size > 0)
+  end
+  
+  def test_find_my_marks
+    @client.find_my_marks
+    assert_not_nil(@client.feed)
+    assert(@client.feed.marks.size > 0)
+  end
+  
+  def test_find_marks_limited_to_5
+    @client.find_marks( :last => 5 )
+    assert_not_nil(@client.feed)
+    assert(@client.feed.marks.size <= 5)
+  end
+  
+  ## 
+  def test_find_marks_begining_at_5
+    
+  end
+end

data/test/test_blogmarks_entry.rb

@@ -0,0 +1,163 @@
+#/bin/env ruby
+#--
+# Copyright (c) 2004 Jonathan Tron
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'test/unit'
+require 'uri'
+require 'rexml/document'
+require 'blogmarks'
+
+class TestMark < Test::Unit::TestCase
+
+  def setup
+    @mark = BlogMarks::Mark.new(  :id             => 'tag:blogmarks.net,2005:marks,432', 
+                                  :url            => URI.parse('http://jonathan.tron.name'), 
+                                  :title          => "Jonathan's DevLog",
+                                  :summary        => "Test",
+                                  :link_related   => URI.parse("http://jonathan.tron.name"), 
+                                  :link_alternate => URI.parse("http://jonathan.tron.name"), 
+                                  :link_image     => URI.parse("http://jonathan.tron.name/images/test.png"), 
+                                  :updated        => Time.new, 
+                                  :published      => Time.new, 
+                                  :author         => 'Jonathan', 
+                                  :edit           => URI.parse("http://api.blogmarks.net/marks/432"),
+                                  :bm_created     => Time.new,
+                                  :public_tags    => %w(blog dev multi\ word),
+                                  :private_tags   => %w(test unit) )
+  end
+  
+  def test_create_error
+    assert_raise( ArgumentError ) {
+      BlogMarks::Mark.new() 
+    }
+  end
+  
+  def test_create
+    assert_not_nil  @mark
+    assert_instance_of(BlogMarks::Mark, @mark)
+  end
+  
+  def test_id
+    assert_equal('tag:blogmarks.net,2005:marks,432', @mark.id)
+  end
+  
+  def test_title
+    assert_equal("Jonathan's DevLog", @mark.title)
+  end
+  
+  def test_link_related
+    assert_instance_of(URI::HTTP, @mark.link_related)
+    assert_equal("http://jonathan.tron.name", @mark.link_related.to_s)
+  end
+  
+  def test_link_alternate
+    assert_instance_of(URI::HTTP, @mark.link_alternate)
+    assert_equal("http://jonathan.tron.name", @mark.link_alternate.to_s)
+  end
+  
+  def test_link_image
+    assert_instance_of(URI::HTTP, @mark.link_image)
+    assert_equal("http://jonathan.tron.name/images/test.png", @mark.link_image.to_s)
+  end
+  
+  def test_updated
+    assert_instance_of(Time, @mark.updated)
+  end
+  
+  def test_published
+    assert_instance_of(Time, @mark.published)
+  end
+  
+  def test_author
+    assert_equal('Jonathan', @mark.author)
+  end
+  
+  def test_edit
+    assert_instance_of(URI::HTTP, @mark.edit)
+    assert_equal('http://api.blogmarks.net/marks/432', @mark.edit.to_s )
+  end
+  
+  def test_bm_created
+    assert_instance_of(Time, @mark.bm_created)
+  end
+  
+  def test_public_tags
+    assert_instance_of(Array, @mark.public_tags)
+    assert_equal(3, @mark.public_tags.size)
+    
+    assert_equal('blog', @mark.public_tags[0] )
+    assert_equal('dev', @mark.public_tags[1])
+    assert_equal("multi word", @mark.public_tags[2])
+  end
+  
+  def test_private_tags
+    assert_instance_of(Array, @mark.private_tags)
+    assert_equal(2, @mark.private_tags.size)
+    
+    assert_equal('test', @mark.private_tags[0] )
+    assert_equal('unit', @mark.private_tags[1])
+  end
+  
+  def test_build_from_xml
+    xml = <<-ENTRY
+      <?xml version="1.0" encoding="UTF-8"?>
+      <feed version="draft-ietf-atompub-format-05:do not deploy" xmlns="http://purl.org/atom/ns#draft-ietf-atompub-format-05" xmlns:bm="http://api.blogmarks.net/ns#">
+        <head>
+          <title>Last public marks from user Jonathan</title>
+          <link rel="alternate" type="application/xhtml+xml" href="http://blogmarks.net/user/Jonathan"/>
+          <updated>2006-01-26T21:58:24Z</updated>
+        </head>
+        <entry>
+          <id>tag:blogmarks.net,2006:marks,323785</id>
+          <title type="TEXT">Don't Meet Your Heroes - The CSS &amp; Web Standards News Compilation Site - DMYH</title>
+          <link rel="related" href="http://www.dontmeetyourheroes.com/index.php" type="text/html"/>
+          <link rel="alternate" href="http://blogmarks.net/user/Jonathan/archives/2006/01/#mark323785" type="application/xhtml+xml" title="Don't Meet Your Heroes - The CSS &amp; Web Standards News Compilation Site - DMYH"/>
+          <link rel="via" href="http://blogmarks.net/user/qoodoll/archives/2006/01/#mark323762" type="text/html"/>
+          <link rel="image" href="http://www.blogmarks.net/screenshots/2006/01/26/1d8ec2781448c994f7e537f3b6d9a1a8.png" type="image/png"/>
+          <updated>2006-01-26T21:58:24Z</updated>
+          <published>2006-01-26T21:58:24Z</published>
+          <author><name>Jonathan</name></author>
+          <category term="http://api.blogmarks.net/tags" sheme="/web" label="web"/>
+          <category term="http://api.blogmarks.net/tags" sheme="/css" label="css"/>
+          <category term="http://api.blogmarks.net/tags" sheme="/site" label="site"/>
+          <category term="http://api.blogmarks.net/tags" sheme="/news" label="news"/>
+          <edit>http://api.blogmarks.net/atom/marks/323785</edit>
+          <bm:created>2006-01-26T21:58:24Z</bm:created>
+        </entry>
+      </feed>
+    ENTRY
+    
+    xml_doc = REXML::Document.new( xml, :ignore_whitespace_nodes => :all )
+    
+    mark = nil
+    xml_doc.root.elements.each( "/feed/entry" ) do |entry|
+      begin
+        mark = BlogMarks::Mark.build_from_xml_element(entry)
+      rescue
+        puts 'Error'
+      end
+    end
+    
+    assert_instance_of(BlogMarks::Mark, mark)
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: blogmarks
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-01-31 00:00:00 +01:00
+summary: Library to access BlogMarks.net bookmarks.
+require_paths: 
+- lib
+email: jonathan@tron.name
+homepage: http://projets.tron.name/ruby/blogmarks
+rubyforge_project: 
+description: BlogMarks provide a simple way to access BlogMarks.net bookmarks system.
+autorequire: builder
+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: 
+authors: 
+- Jonathan Tron
+files: 
+- lib/blogmarks.rb
+- lib/blogmarks/class_attribute_accessors.rb
+- lib/blogmarks/client.rb
+- lib/blogmarks/feed.rb
+- lib/blogmarks/mark.rb
+- lib/blogmarks/tag.rb
+- test/test_blogmarks_client.rb
+- test/test_blogmarks_entry.rb
+- README
+- CHANGES
+- MIT-LICENSE
+test_files: 
+- test/test_blogmarks_client.rb
+- test/test_blogmarks_entry.rb
+rdoc_options: 
+- --title
+- BlogMarks -- Access your Marks
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+- CHANGES
+- MIT-LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.4
+    version: