michelson-needish 0.0.9

data/History.txt

@@ -0,0 +1,24 @@
+== 0.0.9 2008-11-08
+
+* 1 major enhancement:
+  * refactoring request methods
+		*now it returns the response in xml when a need or helps is sended
+	* refactoring CDATA responses
+			*cleaning CDATA from xml from some html text responses
+
+== 0.0.3 2008-05-11
+
+* 1 major enhancement:
+  * new methods in base
+		*new methods in base.rb, helped , tag(), and search()
+
+== 0.0.2 2008-05-07
+
+* 1 major enhancement:
+  * @@apikey desapears
+		*The apikey passes to the method initialize, now is not a global variable, (security issues)
+
+== 0.0.1 2008-05-07
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Miguel Michelson Martinez
+
+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/Manifest.txt

@@ -0,0 +1,19 @@
+History.txt
+License.txt
+Manifest.txt
+PostInstall.txt
+README.txt
+Rakefile
+bin/needish
+lib/needish.rb
+lib/needish/version.rb
+lib/needish/base.rb
+lib/needish/easy_class_maker.rb
+lib/needish/friend.rb
+lib/needish/help.rb
+lib/needish/need.rb
+lib/needish/user.rb
+lib/needish/command.rb
+test/test_helper.rb
+test/test_needish.rb
+

data/PostInstall.txt

@@ -0,0 +1,9 @@
+Instalation Success!! 
+
+For more information on needish gem, see http://animalita.cl/needish-gem
+
+cheers!
+
+
+
+

data/README.txt

@@ -0,0 +1,110 @@
+= needish
+
+* FIX (url)
+ #rake debug_gem > needish.gemspec
+
+== DESCRIPTION:
+
+This Gems provides basic methods to access the Nedish.com api
+
+== FEATURES/PROBLEMS:
+
+lists the user profile, user friends , needs and helps from a need
+sends needs, helps
+
+-todo
+search methods
+make friends etc..
+
+== SYNOPSIS:
+
+*examples
+
+login to needish
+pass to login user and pass AND apikey!! (since 0.0.2)
+
+<pre>login =  Needish::Base.new('miguelmichelson(at)gmail.com','********' ,'apikey2234455566')</pre>
+
+obtain the user logged data
+
+<pre>miguel = login.me</pre>
+
+obtain the user id
+
+<pre>miguel.id</pre>
+
+obtain the user friends
+
+<pre>login.user_friends(miguel.id)</pre>
+
+obtain the needs
+
+<pre>login.user_needs(me.id)</pre>
+
+obtain the needs helps
+
+<pre>login.helps(user_needs(me.id)[0].id)</pre>
+
+Other methods
+
+add need, pass subject and text
+
+<pre>login.add_need('subject','text')</pre>
+
+add help, pass need id and text
+
+<pre>login.add_help(need.id,'text')</pre>
+
+new methods
+
+helped needs
+ <pre>	login.helped </pre>
+
+search by tag
+<pre>	login.tag("tag") </pre>
+ 
+simple search
+<pre>	login.search("term") </pre>
+
+
+== REQUIREMENTS:
+
+this gem requires hricot, 
+
+sudo gem install hpricot
+
+
+== INSTALL:
+
+to install this gem simply do :
+
+git clone git://github.com/michelson/needish-gem.git  
+
+cd needish-gem
+
+sudo gem install pkg/needish-0.0.1.gem
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIXME Miguel Michelson Martinez
+
+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/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/bin/needish

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+#
+#  Created on 2008-7-11.
+#  Copyright (c) 2008. All rights reserved.
+
+begin
+  require 'rubygems'
+  require 'needish'
+  #require 'needish/command'
+  
+rescue LoadError
+  # no rubygems to load, so we fail silently
+end
+
+require 'optparse'
+
+# NOTE: the option -p/--path= is given as an example, and should probably be replaced in your application.
+
+OPTIONS = {
+  :path     => '~'
+}
+MANDATORY_OPTIONS = %w(  )
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+This application is wonderful because...
+
+Usage: #{File.basename($0)} [options]
+
+Options are:
+BANNER
+  opts.separator ""
+  opts.on("-p", "--path=PATH", String,
+          "The root path for selecting files",
+          "Default: ~") { |OPTIONS[:path]| }
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+  opts.parse!(ARGV)
+
+  if MANDATORY_OPTIONS && MANDATORY_OPTIONS.find { |option| OPTIONS[option.to_sym].nil? }
+    puts opts; exit
+  end
+end
+
+path = OPTIONS[:path]
+
+# do stuff

data/lib/needish.rb

@@ -0,0 +1,14 @@
+%w(uri cgi net/http yaml rubygems hpricot active_support).each { |f| require f }
+
+$:.unshift(File.dirname(__FILE__)) unless
+ $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+
+require 'needish/version'
+require 'needish/easy_class_maker'
+require 'needish/base'
+require 'needish/user'
+require 'needish/friend'
+require 'needish/need'
+require 'needish/help'

data/lib/needish/base.rb

@@ -0,0 +1,213 @@
+# very inspired in twitter gem
+# This is the base class for the needish library. It makes all the requests 
+# to needish, parses the xml (using hpricot) and returns ruby objects to play with.
+# The private methods in this one are pretty fun. Be sure to check out users, needs and helps...
+module Needish
+  class UnNeedishable < StandardError; end
+  class CantConnect < UnNeedishable; end
+  class BadResponse < UnNeedishable; end
+  class UnknownTimeline < ArgumentError; end
+  
+  class Base
+    # Needish's url, duh!
+    @@api_url   = 'api.needish.com'
+    # Timelines exposed by the needish api
+    @@timelines = [:friends, :public, :user]
+    
+    def self.timelines
+      @@timelines
+    end
+    
+    # Initializes the configuration for making requests to needish
+    def initialize(email, password, apikey)
+      @config, @config[:email], @config[:password],@config[:apikey] = {}, email, password,"?app_key=#{apikey}"
+    end
+    
+   
+    
+   #returns user data information
+    def me
+        users(request("users/authenticate.xml", :auth => true))
+    end
+    
+    # Returns the profile of a given user, 
+    def user_profile(id)
+      users(request("users/profile/#{id}.xml", :auth => true))
+    end
+    
+    # Returns the profile of a given user, including the recent needs. The needs are ordered by descending date of creation. 
+    def user_needs(id)
+      needs_data(request("users/profile/#{id}.xml", :auth => true))
+    end
+    
+     # Returns an array of users who are in your friends list
+    def friends(id)
+     friends_data(request("users/friends/#{id}.xml", :auth => true))
+    end
+    
+    # Returns the most active needs, ordered by descending number of recent helps. 
+    def hot_needs
+      needs_generic_data(request("needs/hot.xml", :auth => true))
+    end
+    
+    # Returns up to 100 recent public needs, ordered by descending date of creation. 
+    def all_needs
+      needs_generic_data(request("needs/all.xml", :auth => true))
+    end
+    
+    #Returns up to 100 recent needs of the authenticating user friends, ordered by descending date of creation. 
+    def friends_needs
+      needs_generic_data(request("needs/friends.xml", :auth => true))
+    end
+    
+    #Returns up to 100 recent public needs created by the given user, ordered by descending date of creation. 
+    def needs_from_user(id)
+      needs_generic_data(request("needs/user/#{id}.xml", :auth => true))
+    end
+    
+    #Returns the given need
+    def view_need(id)
+      needs_view_data(request("needs/view/#{id}.xml", :auth => true))
+    end
+    
+    # Returns up to 100 helps for the given need, ordered by date of creation. 
+    def helps(id)
+      helps_data(request("needs/helps/#{id}.xml", :auth => true))
+    end
+    
+    #Returns up to 100 recent needs helped by the authenticating user, ordered by descending date of creation of the need.     def helped(id)
+    def helped
+      needs_generic_data(request("needs/helped.xml", :auth => true))
+    end
+    
+    #Returns up to 100 recent needs matching the terms sent, ordered by descending date of creation. 
+    def tag(tag)
+      needs_generic_data(request("needs/tag/#{tag}.xml", :auth => true))
+    end
+    
+    def search(term)
+      needs_generic_data(request("needs/search/#{term}.xml", :auth => true))
+    end
+  
+  
+   #Send data 
+   # Post a new Need for the authenticating user
+   # http://api.needish.com/needs/add.format
+     def add_need(subject, text)
+        url = URI.parse("http://#{@@api_url}/needs/add.xml#{@config[:apikey]}")
+       req = Net::HTTP::Post.new(url.path+@config[:apikey])
+
+        req.basic_auth(@config[:email], @config[:password])
+            req.set_form_data({'text'=>text, 'subject'=>subject})
+
+        res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+    # puts req   
+    ## puts url.path
+    # puts  res
+     needs_view_data(parse(res.body))
+     
+     
+     
+     
+     
+       
+      end
+      
+      # Post a new Need for the authenticating user.
+      
+      def add_help(id, text)
+         url = URI.parse("http://#{@@api_url}/helps/add/#{id}.xml#{@config[:apikey]}")
+         req = Net::HTTP::Post.new(url.path+@config[:apikey])
+
+         req.basic_auth(@config[:email], @config[:password])
+         req.set_form_data({'text' => text})
+
+         response = Net::HTTP.new(url.host).start { |http| http.request(req) }
+           parse(response.body)
+
+          end
+    
+    #to do
+   # twitter style
+    # Befriends the user specified in the ID parameter as the authenticating user.
+   
+   # def create_friendship(id_or_screenname)
+    #  users(request("friends/add/#{id_or_screenname}.xml", :auth => true)).first
+    #end
+    
+    #def destroy_friendship(id_or_screenname)
+     # users(request("friends/destroy/#{id_or_screenname}.xml", :auth => true)).first
+    #end
+    
+    #def follow(id_or_screenname)
+    #  users(request("notifications/follow/#{id_or_screenname}.xml", :auth => true)).first
+    #end
+    
+    #def leave(id_or_screenname)
+    #  users(request("notifications/leave/#{id_or_screenname}.xml", :auth => true)).first
+    #end
+    
+    
+    private
+      # Converts an hpricot doc to an array of statuses
+     
+      # Converts an hpricot doc to an array of ..
+     
+      def users(doc)
+        #(doc/:user).inject([]) { |users, user| users << User.new_from_xml(user); users }
+         User.new_from_xml(doc)
+      end
+      
+      def friends_data(doc)
+       # (doc/:user).inject([]) { |users, user| users << Friend.new_from_xml(user); users }
+        
+        Friend.new_from_xml(doc)
+      end
+      
+      def needs_data(doc)
+        Need.new_from_xml(doc)
+      end
+      
+      def needs_generic_data(doc)
+        Need.generic_from_xml(doc)
+      end
+      def needs_view_data(doc)
+        Need.generic_view_from_xml(doc)
+      end
+      
+      def helps_data(doc)
+        Help.new_from_xml(doc)
+      end
+      
+      # Calls whatever api method requested that deals with statuses
+      # 
+      # ie: call(:public_timeline, :auth => false)
+      def call(method, options={})
+        options.reverse_merge!({ :auth => true, :args => {} })
+        path    = "statuses/#{method.to_s}.xml"
+        path   += '?' + options[:args].inject('') { |qs, h| qs += "#{h[0]}=#{h[1]}&"; qs } unless options[:args].blank?        
+        request(path, options)
+      end
+      
+      def request(path, options={})
+        options.reverse_merge!({:headers => { "User-Agent" => @config[:email] }})
+        begin
+          response = Net::HTTP.start(@@api_url, 80) do |http|
+              req = Net::HTTP::Get.new('/' + path+@config[:apikey], options[:headers])
+              req.basic_auth(@config[:email], @config[:password]) if options[:auth]
+              http.request(req)
+          end
+              #puts req.body
+
+          raise BadResponse unless response.message == 'OK'
+          parse(response.body)
+        rescue
+          raise CantConnect
+        end
+      end
+      
+      def parse(response)
+        Hpricot.XML(response)
+      end
+  end
+end

data/lib/needish/command.rb

@@ -0,0 +1,249 @@
+# The command class is used for the command line interface. 
+# It is only used and included in the bin/twitter file.
+module Twitter
+  class Command
+    @@commands  = [:post, :timeline, :friends, :friend, :followers, :follower, :featured, :important, :follow, :leave, :d]
+    
+    @@template  = <<EOF
+# .twitter
+# 
+# Please fill in fields like this:
+#
+#  email: bla@bla.com
+#  password: secret
+#
+email: 
+password: 
+EOF
+ 
+    class << self
+      def process!
+        command = ARGV.shift
+        
+        if !command.nil? && @@commands.include?(command.intern)
+          send(command)
+        else
+          puts "\nUsage: needish <command> [options]\n\nAvailable Commands:"
+          Needish::Command.commands.each do |c|
+            puts "    - #{c}"
+          end
+        end
+      end
+      
+      def commands
+        @@commands
+      end
+      
+      # Posts an updated status to twitter
+      def post
+        config = create_or_find_config
+        
+        if ARGV.size == 0
+          puts %(\n  You didn't enter a message to post.\n\n  Usage: twitter post "You're fabulous message"\n)
+          exit(0)
+        end
+        
+        post = ARGV.shift
+        print "\nSending needish update"
+        finished = false
+        status = nil
+        progress_thread = Thread.new { until finished; print "."; $stdout.flush; sleep 0.5; end; }
+        post_thread = Thread.new(binding()) { |b|
+          status = Needish::Base.new(config['email'], config['password']).post(post)
+          finished = true
+        }
+        post_thread.join
+        progress_thread.join
+        puts " OK!"
+        puts "Got it! New needish created at: #{status.created_at}\n"
+      end
+      
+      # Shows status, time and user for the specified timeline
+      def timeline
+        config = create_or_find_config
+        
+        timeline = :friends
+        timeline = ARGV.shift.intern if ARGV.size > 0 && Twitter::Base.timelines.include?(ARGV[0].intern)
+        
+        puts
+        Twitter::Base.new(config['email'], config['password']).timeline(timeline).each do |s|
+          puts "#{s.text}\n-- #{s.user.name} at #{s.created_at}"
+          puts
+        end
+      end
+      
+      def friends
+        config = create_or_find_config
+        
+        puts
+        Twitter::Base.new(config['email'], config['password']).friends.each do |u|
+          puts "#{u.name} (#{u.screen_name})"
+          puts "#{u.status.text} at #{u.status.created_at}" unless u.status.nil?
+        end
+      end
+      
+      # Shows last updated status and time for a friend
+      # Needs a screen name
+      def friend
+        config = create_or_find_config
+        
+        if ARGV.size == 0
+          puts %(\n  You forgot to enter a screen name.\n\n  Usage: twitter friend jnunemaker\n)
+          exit(0)
+        end
+        
+        screen_name = ARGV.shift
+        
+        puts
+        found = false
+        Twitter::Base.new(config['email'], config['password']).friends.each do |u|
+          if u.screen_name == screen_name
+            puts "#{u.name} #{u.screen_name}"
+            puts "#{u.status.text} at #{u.status.created_at}" unless u.status.nil?
+            found = true
+          end
+        end
+        
+        puts "Sorry couldn't find a friend of yours with #{screen_name} as a screen name" unless found
+      end
+      
+      # Shows all followers and their last updated status
+      def followers
+        config = create_or_find_config
+        
+        puts
+        Twitter::Base.new(config['email'], config['password']).followers.each do |u|
+          puts "#{u.name} (#{u.screen_name})"
+          puts "#{u.status.text} at #{u.status.created_at}" unless u.status.nil?
+        end
+      end
+      
+      # Shows last updated status and time for a follower
+      # Needs a screen name
+      def follower
+        config = create_or_find_config
+        
+        if ARGV.size == 0
+          puts %(\n  You forgot to enter a screen name.\n\n  Usage: twitter follower jnunemaker\n)
+          exit(0)
+        end
+        
+        screen_name = ARGV.shift
+        
+        puts
+        found = false
+        Twitter::Base.new(config['email'], config['password']).followers.each do |u|
+          if u.screen_name == screen_name
+            puts "#{u.name} (#{u.screen_name})"
+            puts "#{u.status.text} at #{u.status.created_at}" unless u.status.nil?
+            found = true
+          end
+        end
+        
+        puts "Sorry couldn't find a follower of yours with #{screen_name} as a screen name" unless found
+      end
+      
+      def featured
+        puts
+        puts 'This is all implemented, just waiting for twitter to get the api call working'
+        config = create_or_find_config
+        
+        puts
+        Twitter::Base.new(config['email'], config['password']).featured.each do |u|
+          puts "#{u.name} last updated #{u.status.created_at}\n-- #{u.status.text}"
+          puts
+        end
+      end
+      
+      def important
+        config = create_or_find_config
+        
+        puts
+        if config['important'].nil?
+          puts "You have not listed your most important twitter buddies in your config file.\nYou can add important twitterers by adding the following to your config file:\nimportant:\n- jnunemaker\n- frankfurter"
+        else
+          Twitter::Base.new(config['email'], config['password']).timeline(:friends).each do |s|          
+            if config['important'].include?(s.user.screen_name)
+              puts "#{s.text}\n-- #{s.user.name} at #{s.created_at}"
+              puts
+            end
+          end
+        end
+      end
+      
+      def follow
+        config = create_or_find_config
+        
+        if ARGV.size == 0
+          puts %(\n  You forgot to enter a screen name or id to follow.\n\n  Usage: twitter follow jnunemaker\n)
+          exit(0)
+        end
+        
+        screen_name = ARGV.shift
+        
+        puts
+        found = false
+        begin
+          Twitter::Base.new(config['email'], config['password']).follow(screen_name)
+          puts "You are now following notifications for #{screen_name}."
+        rescue
+          puts "FAIL: Somethin went wrong. Sorry."
+        end
+      end
+      
+      def leave
+        config = create_or_find_config
+        
+        if ARGV.size == 0
+          puts %(\n  You forgot to enter a screen name or id to leave.\n\n  Usage: twitter leave jnunemaker\n)
+          exit(0)
+        end
+        
+        screen_name = ARGV.shift
+        
+        puts
+        found = false
+        begin
+          Twitter::Base.new(config['email'], config['password']).leave(screen_name)
+          puts "You are no longer following notifications for #{screen_name}."
+        rescue
+          puts "FAIL: Somethin went wrong. Sorry."
+        end
+      end
+      
+      # Posts a direct message to twitter
+      def d
+        config = create_or_find_config
+        if ARGV.size != 2
+          puts %(\n  You didn't do it right.\n\n  Usage: twitter d jnunemaker "You're fabulous message"\n)
+          exit(0)
+        end
+
+        user = ARGV.shift
+        post = ARGV.shift
+
+        status = Twitter::Base.new(config['email'], config['password']).d(user, post)
+        puts "\nDirect message sent to #{user}.\n"
+      end
+      
+      private
+        # Checks for the config, creates it if not found
+        def create_or_find_config
+          home = ENV['HOME'] || ENV['USERPROFILE'] || ENV['HOMEPATH']
+          begin
+            config = YAML::load open(home + "/.needish")
+          rescue
+            open(home + '/.twitter','w').write(@@template)
+            config = YAML::load open(home + "/.needish")
+          end
+          
+          if config['email'] == nil or config['password'] == nil
+            puts "Please edit ~/.twitter to include your twitter email and password\nTextmate users: mate ~/.twitter"
+            exit(0)
+          end
+          
+          config
+        end
+    end
+  end
+end

data/lib/needish/easy_class_maker.rb

@@ -0,0 +1,43 @@
+# This is pretty much just a macro for creating a class that allows
+# using a block to initialize stuff and to define getters and setters
+# really quickly.
+module Needish
+  module EasyClassMaker
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      # creates the attributes class variable and creates each attribute's accessor methods
+      def attributes(*attrs)
+        @@attributes = attrs
+        @@attributes.each { |a| attr_accessor a }
+      end
+      
+      # read method for attributes class variable
+      def self.attributes; @@attributes end
+    end
+    
+    # allows for any class that includes this to use a block to initialize
+    # variables instead of assigning each one seperately
+    # 
+    # Example: 
+    # 
+    # instead of...
+    # 
+    # s = Status.new
+    # s.foo = 'thing'
+    # s.bar = 'another thing'
+    #
+    # you can ...
+    # 
+    # Status.new do |s|
+    #   s.foo = 'thing'
+    #   s.bar = 'another thing'
+    # end
+    def initialize
+      yield self if block_given?
+    end
+  end
+end

data/lib/needish/friend.rb

@@ -0,0 +1,35 @@
+module Needish
+  class Friend
+    include EasyClassMaker
+    
+   attributes :id,:name,:lastname,:nickname,:pictureurl,:displayname,:biography,
+   :userneeds,:biography,:friendstatus
+   
+    
+    class << self
+     
+      # Creates a new user from a piece of xml
+      def new_from_xml(xml)
+       
+        result = []
+
+        xml.search("user").each do  |user|
+          Friend.new do |u|
+                u.id                =        user[:id] 
+                u.name              =         user[:name]
+                u.lastname          =         user[:lastname]
+                u.nickname          =         user[:nickname]
+                u.pictureurl        =         user[:pictureurl]
+                u.displayname       =         user[:displayname]
+           result << u
+           end
+           
+        end
+
+        return result
+       
+        
+      end
+    end
+  end
+end

data/lib/needish/help.rb

@@ -0,0 +1,51 @@
+module Needish
+  class Help
+    include EasyClassMaker
+    
+   attributes :id,:created,:helps,:stared,:timediff,:text,
+   :user_id,:user_name,:user_lastname,:user_nickname,:pictureurl,:displayname
+   
+    
+    class << self
+     
+      # Creates a new user from a piece of xml
+      def new_from_xml(xml)
+       
+        result = []
+
+         xml.search("help").each do  |help|
+          
+          Help.new do |u|
+                u.id           =     help[:id] 
+                u.created      =     Time.at(help[:created].to_i)
+                u.stared        =     help[:stars]
+                u.timediff     =     help[:timediff]
+                
+            (help/:text).each do |text|
+              u.text     =     text.inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+            end
+            
+            
+            (help/:user).each do |user|
+              u.user_id     =     user[:id]
+              u.user_name     =     user[:name]
+              u.user_lastname     =     user[:lastname]
+              u.user_nickname     =     user[:user_nickname]
+              u.pictureurl    =     user[:pictureurl]
+              u.displayname    =     user[:displayname]
+            end
+    
+    
+    
+            result << u
+            
+            
+         end  
+        end
+
+        return result
+
+      end
+    end
+  end
+end

data/lib/needish/need.rb

@@ -0,0 +1,127 @@
+module Needish
+  class Need
+    include EasyClassMaker
+    
+   attributes :id,:created,:city,:timediff,:helps,:status,:subject,:text,
+   :user_id,:user_name,:user_lastname,:user_nickname,:pictureurl,:displayname,:attachments,:biography,
+   :attachment_id, :attachment_fileurl,:attachment_type,:attachment_actualurl,:attachment_name
+   
+   
+    
+    class << self
+     
+      # Creates a new user from a piece of xml
+      def new_from_xml(xml)
+       
+        result = []
+
+        xml.search("userNeeds").each do  |userNeeds|
+          (userNeeds/:need).each do |need|
+          Need.new do |u|
+                u.id           =     need[:id] 
+                u.created      =     Time.at(need[:created].to_i)
+                u.city         =     need[:city]
+                u.timediff     =     need[:timediff]
+                u.status       =     need[:status]
+                (need/:subject).each do |subject|
+                u.subject     =         subject.inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+              end
+              (need/:text).each do |text|
+              u.text     =         text.inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+            end
+            result << u
+           end 
+         end  
+        end
+        return result
+      end
+      
+      
+      
+      
+      
+      def generic_from_xml(xml)
+       
+        result = []
+
+        xml.search("needs").each do  |userNeeds|
+          (userNeeds/:need).each do |need|
+          Need.new do |u|
+                u.id           =     need[:id] 
+                u.created      =     Time.at(need[:created].to_i)
+                u.city         =     need[:city]
+                u.timediff     =     need[:timediff]
+                u.status       =     need[:status]
+                
+               
+                
+              (need/:subject).each do |subject|
+                u.subject     =         subject.inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+              end
+              (need/:text).each do |text|
+              u.text     =         text.inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+              end
+              
+              
+            #si hay attachment
+            if(need/:attachment)
+                (need/:attachment).each do |attch|
+                u.attachment_id = attch[:id]
+                u.attachment_fileurl = attch[:fileurl]
+                u.attachment_type = attch[:type]
+                u.attachment_actualurl = attch[:actualurl]
+                u.attachment_name = (attch/:name).inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+              end
+            end
+              
+              #cargamos al user para helped si existe
+            if(need/:user)
+              (need/:user).each do |user|
+                u.user_id   =  user[:id]
+                u.user_name   = user[:name]
+                u.user_lastname    = user[:lastname]
+                u.pictureurl   = user[:pictureurl]
+                u.user_nickname = user[:user_nickname]
+                u.biography   = (user/:biography).inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+               # u.attachments   = user[:attachments]
+              end
+            end
+              
+            result << u
+           end
+         end 
+        end
+        return result
+      end
+      
+      
+      def generic_view_from_xml(xml)
+        result = []
+
+        xml.search("need").each do  |need|
+          
+          Need.new do |u|
+                u.id           =     need[:id] 
+                u.created      =     Time.at(need[:created].to_i)
+                u.city         =     need[:city]
+                u.timediff     =     need[:timediff]
+                u.status       =     need[:status]
+            
+                (need/:subject).each do |subject|
+                u.subject     =         subject.inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+              end
+              
+              u.text     =         need.search('text').first.inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+       
+            result << u
+         end 
+        end
+        return result[0]
+      end
+     
+     
+     
+      ##
+    end
+  end
+end

data/lib/needish/user.rb

@@ -0,0 +1,29 @@
+module Needish
+  class User
+    include EasyClassMaker
+       
+   attributes :id,:name,:lastname,:nickname,:pictureurl,:displayname,:biography,
+   :userneeds
+   
+    
+    class << self
+      # Creates a new user from a piece of xml
+      def new_from_xml(xml)
+        User.new do |u|
+       
+        
+          u.id                           = xml.search("user").first[:id]
+          u.name                         = xml.search("user").first[:name]
+          u.lastname                     = xml.search("user").first[:lastname]
+          u.nickname                   = xml.search("user").first[:nickname]
+          u.pictureurl                   = xml.search("user").first[:pictureurl]
+          u.displayname                  = xml.search("user").first[:displayname]
+          u.biography                   = xml.search('biobraphy').inner_html.gsub!(/\<\!\[CDATA\[(.*)\]\]\>/m, '\1')
+          
+          
+       
+        end
+      end
+    end
+  end
+end

data/lib/needish/version.rb

@@ -0,0 +1,9 @@
+module Needish
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 9
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/needish'

data/test/test_needish.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestNeedish < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: michelson-needish
+version: !ruby/object:Gem::Version 
+  version: 0.0.9
+platform: ruby
+authors: 
+- Miguel Michelson Martinez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-08 00:00:00 -08:00
+default_executable: needish
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: This gem provides methods to access the needish.com api
+email: 
+- miguelmichelson@gmail.com
+executables: 
+- needish
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- PostInstall.txt
+- README.txt
+files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- PostInstall.txt
+- README.txt
+- Rakefile
+- bin/needish
+- lib/needish.rb
+- lib/needish/version.rb
+- lib/needish/base.rb
+- lib/needish/easy_class_maker.rb
+- lib/needish/friend.rb
+- lib/needish/help.rb
+- lib/needish/need.rb
+- lib/needish/user.rb
+- lib/needish/command.rb
+- test/test_helper.rb
+- test/test_needish.rb
+has_rdoc: true
+homepage: http://needish-gem.rubyforge.org
+post_install_message: |+
+  Instalation Success!! 
+  
+  For more information on needish gem, see http://animalita.cl/needish-gem
+  
+  cheers!
+  
+  
+  
+  
+rdoc_options: 
+- --main
+- README.txt
+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: needish-gem
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: This gem provides methods to access the needish.com api
+test_files: 
+- test/test_helper.rb
+- test/test_needish.rb