oos4ruby 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.1.0 2007-09-28
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2007 David Calavera
+
+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,39 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/oos4ruby.rb
+lib/oos4ruby/auth.rb
+lib/oos4ruby/bean.rb
+lib/oos4ruby/category.rb
+lib/oos4ruby/collection.rb
+lib/oos4ruby/contact.rb
+lib/oos4ruby/contacts.rb
+lib/oos4ruby/entry.rb
+lib/oos4ruby/feed.rb
+lib/oos4ruby/http_invoker.rb
+lib/oos4ruby/oos.rb
+lib/oos4ruby/search.rb
+lib/oos4ruby/service.rb
+lib/oos4ruby/site.rb
+lib/oos4ruby/sites.rb
+lib/oos4ruby/user.rb
+lib/oos4ruby/version.rb
+log/debug.log
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_helper.rb
+test/test_oos4ruby.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1 @@
+README

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/config/hoe.rb

@@ -0,0 +1,70 @@
+require 'oos4ruby/version'
+
+AUTHOR = 'David Calavera'  # can also be an array of Authors
+EMAIL = "david.calavera@gmail.com"
+DESCRIPTION = "oos4ruby is a ruby binding for the 11870 API"
+GEM_NAME = 'oos4ruby' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'oos4r' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Oos4ruby::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'oos4ruby documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\\n\\n")
+  p.extra_deps = [ ['mime-types', '>=1.5'] ]     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')

data/config/requirements.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'oos4ruby'

data/lib/oos4ruby/auth.rb

@@ -0,0 +1,39 @@
+require 'digest/md5'
+require 'digest/sha1'
+
+class Auth
+  
+  def initialize(username, password, method)
+    @username = username
+    @password = password
+    @method = method
+  end
+  
+  def add_to(req)
+    wsse(req) if method?:wsse
+    app(req) if method?:app
+  end
+  
+  def method?(method)
+    @method == method
+  end
+  
+  private
+  def wsse(req)
+    nonce = Array.new(10){ rand(0x1000000) }.pack('I*')
+    nonce_b64 = [nonce].pack("m").chomp
+    now = Time.now.gmtime.strftime("%FT%TZ")
+    digest = [Digest::SHA1.digest(nonce_b64 + now + @password)].pack("m").chomp
+
+    req['Authorization'] = 'WSSE realm="11870.com", profile="UsernameToken"'
+    req['X-WSSE'] = %Q<UsernameToken Username="#{@username}", PasswordDigest="#{digest}", Nonce="#{nonce_b64}", Created="#{now}">
+  end
+  
+  def app(req)
+    req['appToken'], req['authSign'] = @username, Digest::MD5.hexdigest( "#{@username}#{@password}" )
+  end
+  
+end
+
+
+

data/lib/oos4ruby/bean.rb

@@ -0,0 +1,189 @@
+include Oos4ruby
+
+module Bean
+  def self.append_features(base) #:nodoc:
+    super
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def define_el_reader(opts = {})
+      if !opts.empty?
+        opts.each_pair { |key, value|
+          value.each { |field_name|
+            define_method(field_name) do            
+              name = field_name.to_s.gsub(/_/, '')
+              begin
+                child = @xml.child(name, key) if @xml.instance_of?Oos4ruby::Entry
+                child = REXML::XPath.first(@xml, name, key) if @xml.instance_of? REXML::Element
+                return child.text if child
+              rescue => e                
+                puts e.backtrace.join("\n")
+              end
+            end
+          }
+        }
+      end
+    end
+    
+    def set_variable(options = {})
+      if options.empty?
+        options.each_pair { |key, value|
+          class_variable_set("@@#{key.to_s}".to_sym, value) 
+        }
+      end
+    end
+      
+    def define_attr_reader(opts = {})
+      if !opts.empty?
+        opts.each_pair { |namespace, value|
+          if value.is_a?Array
+            value.each { |field|            
+                define_method(field) do
+                  name = field.to_s.gsub(/_/, '')
+                  begin
+                    attr = @xml.attribute(name, namespace) if @xml.instance_of? REXML::Element
+                    return attr.value
+                  rescue
+                    #ATTRIBUTE NOT FOUND
+                  end                  
+                end              
+            }
+          elsif value.is_a?Hash
+            value.each_pair { |el, attr|
+              define_method("#{el}_#{attr}") do
+                el = el.to_s.gsub(/_/, '')
+                
+                prefix = 'atom'
+                XmlNamespaces.each_pair { |name_key, name_value|
+                  prefix = name_key if name_value.to_s == namespace.to_s
+                }
+                
+                elem = @xml.child(el, namespace) if @xml.instance_of?Oos4ruby::Entry
+                elem = REXML::XPath.first(@xml, "./#{prefix}:#{el}", namespace) if @xml.instance_of?REXML::Element
+                  
+                if (attr.is_a?Symbol)
+                  attr = attr.to_s.gsub(/_/, '')
+                  begin
+                    attr_value = elem.attribute(attr, namespace)
+                    return attr_value.value
+                  rescue
+                    #ATTRIBUTE NOT FOUND
+                  end
+                elsif attr.is_a?Hash
+                  attr.each_pair { |attr_name, attr_namespace|
+                  attr_name = attr_name.to_s.gsub(/_/, '')
+                  begin
+                    attr_value = elem.attribute(attr_name, attr_namespace)
+                    return attr_value.value
+                  rescue
+                    #ATTRIBUTE NOT FOUND
+                  end
+                  }
+                end
+              end
+            }
+          end
+        }
+      end
+    end
+  end
+  
+  def make_id
+    id = ''
+    5.times { id += rand(1000000).to_s }
+    "Oos4ruby:11870.com,2007:#{id}"
+  end
+    
+  def add_element(base, new_el, text, attrs = {})
+    el = base.add_element new_el.to_s, attrs
+    el.text = text
+    base
+  end
+  
+  def add_category(xml, term, scheme)
+    xml.add_category(term.to_s, scheme)
+  end
+  
+  def remove_category(xml, term = nil, scheme = nil)
+    if xml.is_a?Entry
+    hash = {}
+    hash[:term] = term if term
+    hash[:scheme] = scheme if scheme      
+    cat = xml.category( hash )
+    xml.delete_category( cat ) if cat
+    elsif xml.is_a?REXML::Element
+      xml.delete_element c
+    end
+  end
+  
+  def create_entry
+    entry = REXML::Element.new('entry')
+    entry.add_namespace AtomNamespace
+    XmlNamespaces.each_pair { |prefix, namespace|
+      unless prefix == 'atom' || prefix == 'gml'
+        entry.add_namespace prefix, namespace
+      end
+    }
+    entry
+  end
+ 
+  class BeanClass
+    def author
+      @entry.child('author/name').text
+    end
+    
+    def to_xml
+      @xml.to_s
+    end
+    
+    def to_s
+      @xml.to_s
+    end
+    
+    def update!
+      edit_link = @xml.link('edit')
+
+      getter = HTTPInvoker.new(edit_link, @auth)
+
+      worked = getter.get
+      if worked
+        @xml = Entry.new( getter.body )
+        load!
+
+        putter = HTTPInvoker.new edit_link, @auth
+        worked = putter.put AtomEntryContentType, @xml.to_s
+
+        raise RuntimeError.new unless worked
+      else
+        raise RuntimeError.new unless worked
+      end    
+    end
+    
+    def delete!
+      edit_link = @xml.link('edit')
+
+      deleter = HTTPInvoker.new(edit_link, @auth)
+
+      worked = deleter.delete
+
+      raise RuntimeError.new unless worked    
+    end
+    
+    protected
+    def add_category(term, scheme)
+      Bean.add_category(@xml, term, scheme)
+    end
+    
+    def update_category(new_term, new_scheme, old_term = nil, old_scheme = nil)
+      remove_category old_term, old_scheme
+      add_category new_term, new_scheme
+    end
+    
+    def remove_category(term = nil, scheme = nil)
+      Bean.remove_category(@xml, term, scheme)
+    end
+    
+  end
+end
+

data/lib/oos4ruby/category.rb

@@ -0,0 +1,28 @@
+include Bean
+
+module Oos4ruby
+class Category
+  
+  define_attr_reader({
+    AtomNamespace => [:term, :scheme],
+    OosNamespace => [:frecuency]
+  })
+  
+  def initialize(term, scheme = nil)
+    unless term.instance_of?(REXML::Element)
+      @term = term
+      @scheme = scheme
+      @xml = REXML::Element.new 'category'
+      @xml.add_attributes 'term' => @term, 'scheme' => @scheme
+    else
+      @xml = term
+    end
+  end  
+  
+  def to_s
+    return @xml.to_s
+  end
+end
+end
+
+

data/lib/oos4ruby/collection.rb

@@ -0,0 +1,96 @@
+module Oos4ruby
+class Collection  
+  
+  attr_reader :entries
+  
+  def initialize(feed, auth, slug = nil)
+    @feed = feed
+    @auth = auth
+    @slug = slug
+  end
+  
+  def next_page?
+    @feed.next?
+  end
+  
+  def previous_page?
+    @feed.previous?
+  end
+  
+  def next_page    
+    return get_page(@feed.next) if next_page?
+  end
+  
+  def previous_page
+    return get_page(@feed.previous) if previous_page?   
+  end
+  
+  def next_page!
+    return get_page!(@feed.next)
+  end
+  
+  def previous!
+    return get_page!(@feed.previous)
+  end
+  
+  def all
+    all = @entries
+    aux = self
+    while aux.next_page?
+      next_page = aux.next_page
+      next_page.entries.each {|entry| all << entry}
+      aux = next_page
+    end
+    return all
+  end
+    
+  def refresh!
+    return get_page!(@feed.self_link)
+  end
+  
+  def to_s
+    @entries.join("\n")
+  end
+  
+  def create!(opts = {})
+    opts[:author] = REXML::XPath.first(@feed.xml, 'author', XmlNamespaces)
+    
+    new_entry = Site.dump! opts, @slug if self.instance_of?Sites
+    new_entry = Contact.dump! opts, @slug if self.instance_of?Contacts
+    
+    poster = HTTPInvoker.new( @feed.self_link, @auth)
+    
+    worked = poster.post AtomEntryContentType, "<?xml version='1.0' ?>\n" + new_entry.to_s
+        
+    raise RuntimeError.new unless worked
+    return Site.new(poster.entry, @auth, @slug) if self.instance_of?Sites
+    return Contact.new(poster.entry, @auth, @slug) if self.instance_of?Contacts
+  end
+  
+  private
+  def get_page(link)
+    getter = HTTPInvoker.new(link, @auth) 
+    worked = getter.get
+      
+    return convert(getter.body) if worked
+  end
+  
+  def get_page!(link)
+    getter = HTTPInvoker.new(link, @auth)
+    worked = getter.get
+    if worked
+      @feed = Feed.read(getter.body)
+      @entries = convert(getter.body).entries
+      return self
+    end
+  end
+  
+  def convert( body )
+    return Sites.new( Feed.read( body ), @auth, @slug ) if self.instance_of?(Sites)
+    return Contacts.new( Feed.read( body ), @auth, @slug ) if self.instance_of?(Contacts)
+  end
+  
+end
+end
+
+

data/lib/oos4ruby/contact.rb

@@ -0,0 +1,72 @@
+
+include Bean
+
+module Oos4ruby
+class Contact < BeanClass
+  
+  define_el_reader AtomNamespace => [:title, :updated]    
+  
+  attr_writer :trusted
+  
+  alias :nick :title
+  
+  def initialize(xml, auth, slug)
+    @xml = xml
+    @auth = auth
+    @slug = slug
+  end
+  
+  def Contact.find_by_user( auth, slug, opts = {} )
+    raise Oos4ruby::UnknownUser if slug.nil?
+    
+    uri = CONTACTS_URL + "/#{slug}"
+    
+    getter = HTTPInvoker.new(uri, auth)
+    
+    worked = getter.get
+    
+    Contacts.new(Feed.read(getter.body), auth, slug) if worked
+  end
+  
+  def data         
+    @data = User.find @auth, @xml.link('userInfo') unless @data
+    @data
+  end
+  
+  def trusted?
+    trusted = @xml.first("./atom:category[@scheme=\"#{TRUSTED_URL}\"]")
+    trusted = Category.new trusted
+    trusted.term.downcase == 'true'
+  end
+  
+  def Contact.dump!(opts, slug)
+    entry = create_entry
+    
+    entry.add_element opts[:author]    
+    add_element entry, 'updated', DateTime.now
+    add_element entry, 'id', make_id
+    
+    add_element entry, 'title', (opts[:contact] || opts[:slug] || opts[:title])
+    add_element entry, 'content', ''
+    
+    if opts[:trusted]
+      if opts[:trusted].is_a?REXML::Element
+        entry.add_element opts[:trusted]
+      else      
+        add_category entry, opts[:trusted], TRUSTED_URL
+      end
+    end
+    
+    entry
+  end
+    
+  private
+  def load!
+    update_category @trusted, TRUSTED_URL, nil, TRUSTED_URL unless @trusted.nil?
+    @xml.add_child('content', nil, nil, {:type => 'html'})
+  end
+  
+end
+end
+
+

data/lib/oos4ruby/contacts.rb

@@ -0,0 +1,11 @@
+
+module Oos4ruby
+class Contacts < Collection
+  def initialize(feed, auth, slug)
+    super(feed, auth, slug)
+    @entries = feed.entries.map {|entry| Contact.new(entry, @auth, @slug) }
+  end
+end
+end
+
+

data/lib/oos4ruby/entry.rb

@@ -0,0 +1,91 @@
+
+require 'rexml/document'
+require 'rexml/xpath'
+
+module Oos4ruby
+class Entry
+
+  def initialize(node)
+    if node.class == String
+      @element = REXML::Document.new(node, { :raw => nil }).root
+    else
+      @element = node
+    end    
+  end
+
+  def to_s
+    "<?xml version='1.0' ?>\n" + @element.to_s
+  end
+
+  def child(field, namespace = nil)
+    if (namespace)
+      thisNS = {}
+      prefix = 'NS'
+      thisNS[prefix] = namespace
+    else
+      prefix = 'atom'
+      thisNS = XmlNamespaces
+    end    
+    return REXML::XPath.first(@element, "./#{prefix}:#{field}", thisNS)
+  end
+  
+  def add_child(name, prefix = nil, namespace = nil, attr = {})
+    name = (prefix || 'atom') + ':' + name
+    e = REXML::Element.new( name, @element )
+    if prefix && namespace
+      e.add_namespace(prefix, namespace) 
+    else
+      e.add_namespace('atom', AtomNamespace)
+    end
+    if !attr.empty?
+      attr.each_pair { |key, value| e.add_attribute(key.to_s, value) }
+    end
+    e
+  end
+
+  def category( cat )
+    first = true
+    xpath = "./atom:category["
+    if cat[:term]
+      xpath += "@term=\"#{cat[:term]}\""
+      first = false
+    end
+    xpath += " and " unless first
+    if cat[:scheme]
+      xpath += "@scheme=\"#{cat[:scheme]}\""
+    end    
+    xpath += "]"
+    REXML::XPath.first(@element, xpath, XmlNamespaces)
+  end
+  
+  def add_category(term, scheme = nil, label = nil)
+    c = @element.add_category(term, scheme, label)    
+    c
+  end
+
+  def delete_category(c)
+    @element.delete_element c
+  end
+  
+  def link(rel)    
+    a = REXML::XPath.first(@element, "./atom:link[@rel=\"#{rel}\"]", XmlNamespaces)
+    if a      
+      uri = URI.parse a.attributes['href']
+      if uri.absolute?
+        return uri
+      else
+        return URI.parse(OOS_URL).merge(uri)
+      end      
+    end    
+  end
+    
+  def match(xp)
+    REXML::XPath.match(@element, xp, XmlNamespaces)
+  end
+
+  def first(xp)
+    REXML::XPath.first(@element, xp, XmlNamespaces)
+  end
+
+end
+end