monkeyhelper-muddyit_fu 0.1.0 → 0.1.1

data/CHANGELOG

@@ -1,5 +1,11 @@
 muddyit_fu Changelog
 
+0.2.1
+- Updated to reflect new api
+
+0.2.0
+- Added new oauth style authentication method
+
 0.1.0
 - Moved to using Jeweller for gem management, should fix previously empty gems
 

data/README.rdoc

@@ -1,20 +1,38 @@
-= muddyit-fu
+= muddyit_fu
+
+== Installation
+
+sudo gem install muddyit-fu
 
 == Getting started
 
-   You need to first get an account a muddy.it and create a site to hold content.
+muddy.it uses oauth to manage it's api access.  To access the muddy.it data
+programmatically you will need to register an application.  Login and visit :
 
-== Installation
+http://www.muddy.it/oauth_clients/
+
+You can register an application here, a callback URI isn't required.
+
+The 'consumer token' and 'consumer secret' are used to generate a token for
+accessing muddy.it.  For further details and an example of how to programatically
+generate a new access token for muddy.it see here :
 
-  sudo gem install muddyit-fu
+http://stakeventures.com/articles/2008/02/23/developing-oauth-clients-in-ruby
+
+See the 'Authorising clients using irb' section for a sample irb session.
+
+These details are then used to provide access to the service.  The credentials
+can be stored in a yml file, an example of which is provided below.
 
 == Example muddyit.yml
 
----
-access_key_id: "YOUR KEY"
-secret_access_key: "YOUR SECRET"
+  ---
+  consumer_key: "YOUR_CONSUMER_KEY"
+  consumer_secret: "YOUR_CONSUMER_SECRET"
+  access_token: "YOUR_ACCESS_TOKEN"
+  access_token_secret: "YOUR_ACCESS_TOKEN_SECRET"
 
-== Sites example
+== Retrieving a site
 
   require 'muddyit_fu'
   muddyit = Muddyit.new('muddyit.yml')
@@ -27,13 +45,15 @@ secret_access_key: "YOUR SECRET"
   require 'muddyit_fu'
   muddyit = Muddyit.new('muddyit.yml')
   site = muddyit.sites.first
-  site.pages.categorise(:identifier => 'http://news.bbc.co.uk/1/hi/uk_politics/8011321.stm')
+  site.pages.categorise({:identifier => 'http://news.bbc.co.uk/1/hi/uk_politics/8011321.stm'}, {:minium_confidence => 0.2})
 
 == View categorised pages
 
   require 'muddyit_fu'
-  muddyit =  Muddyit.new(:access_key_id => 'aaaaaaaaaaaaaa',
-                         :secret_access_key => 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
+  muddyit =  Muddyit.new(:consumer_key => 'aaa',
+                         :consumer_secret => 'bbb',
+                         :access_token => 'ccc',
+                         :access_token_secret => 'ddd')
   site = muddyit.sites.first
   site.pages.index do |page|
     puts page.content_data.title
@@ -45,8 +65,7 @@ secret_access_key: "YOUR SECRET"
 == View all pages containing 'Gordon Brown'
 
   require 'muddyit_fu'
-  muddyit =  Muddyit.new(:access_key_id => 'aaaaaaaaaaaaaa',
-                         :secret_access_key => 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
+  muddyit = Muddyit.new('muddyit.yml')
   site = muddyit.sites.first
   site.pages.find_by_entity('http://dbpedia.org/resource/Gordon_Brown') do |page|
     puts page.identifier
@@ -55,8 +74,7 @@ secret_access_key: "YOUR SECRET"
 == Find related entities for 'Gordon Brown'
 
   require 'muddyit_fu'
-  muddyit =  Muddyit.new(:access_key_id => 'aaaaaaaaaaaaaa',
-                         :secret_access_key => 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
+  muddyit = Muddyit.new('muddyit.yml')
   site = muddyit.sites.first
   site.pages.related_entities('http://dbpedia.org/resource/Gordon_Brown').each do |entity|
     puts "#{entity.uri} : #{entity.confidence}"
@@ -65,8 +83,7 @@ secret_access_key: "YOUR SECRET"
 == Find related content for : http://news.bbc.co.uk/1/hi/uk_politics/7878418.stm
 
   require 'muddyit_fu'
-  muddyit =  Muddyit.new(:access_key_id => 'aaaaaaaaaaaaaa',
-                         :secret_access_key => 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
+  muddyit = Muddyit.new('muddyit.yml')
   site = muddyit.sites.first
   page = site.pages.find('http://news.bbc.co.uk/1/hi/uk_politics/7878418.stm')
   puts "Our page : #{page.content_data.title}\n\n"
@@ -74,6 +91,56 @@ secret_access_key: "YOUR SECRET"
     puts "#{results[:page].content_data.title} #{results[:count]}"
   end
 
+== Authorising clients using irb
+
+  robl@fry:~/$ irb
+  irb(main):002:0> require 'rubygems'
+  => true
+  irb(main):003:0> require 'oauth'
+  => true
+  irb(main):004:0> require 'oauth/consumer'
+  => false
+  irb(main):005:0> @consumer=OAuth::Consumer.new "yourtoken", "yoursecret", {:site => 'http://www.muddy.it' }
+  => #<OAuth::Consumer:0xb7683b7c @key="yourtoken", @secret="yoursecret", @options={:oauth_version=>"1.0",
+  :signature_method=>"HMAC-SHA1", :request_token_path=>"/oauth/request_token",
+  :site=>"http://www.muddy.it", :scheme=>:header,
+  :authorize_path=>"/oauth/authorize", :access_token_path=>"/oauth/access_token",
+  :http_method=>:post}>
+  irb(main):006:0> @request_token=@consumer.get_request_token
+  => #<OAuth::RequestToken:0xb76778e0 @consumer=#<OAuth::Consumer:0xb7683b7c @key="tokenkey",
+  @http=#<Net::HTTP www.muddy.it:80 open=false>, @http_method=:post,
+  @secret="tokensecret", @options={:oauth_version=>"1.0", :signature_method=>"HMAC-SHA1",
+  :request_token_path=>"/oauth/request_token", :site=>"http://www.muddy.it",
+  :scheme=>:header, :authorize_path=>"/oauth/authorize", :access_token_path=>"/oauth/access_token",
+  :http_method=>:post}>, @token="tokenkey", @secret="tokensecret">
+  irb(main):007:0> @request_token.authorize_url
+  => "http://www.muddy.it/oauth/authorize?oauth_token=tokenkey"
+
+To authorise the application, visit the URL, check the 'authorize access' box and
+save.  The request token can now be exchanged for an access token :
+
+  irb(main):008:0> @access_token=@request_token.get_access_token
+  => #<OAuth::AccessToken:0xb7667c10 @consumer=#<OAuth::Consumer:0xb7683b7c @key="accesstoken_key",
+  @http=#<Net::HTTP www.muddy.it:80 open=false>, @http_method=:post,
+  @secret="accesstoken_secret", @options={:oauth_version=>"1.0",
+  :signature_method=>"HMAC-SHA1", :request_token_path=>"/oauth/request_token",
+  :site=>"http://www.muddy.it", :scheme=>:header, :authorize_path=>"/oauth/authorize",
+  :access_token_path=>"/oauth/access_token", :http_method=>:post}>, @token="accesstoken",
+  @secret="accesstoken_secret">
+
+This token can also be used to access the service :
+
+  irb(main):016:0> res = @access_token.get "/sites.json"
+  => #<Net::HTTPOK 200 OK readbody=true>
+  irb(main):017:0> res.body
+  ....
+
+The access token credentials to be used with muddyit_fu are :
+
+  irb(main):011:0> @access_token.token
+  => "sometoken"
+  irb(main):012:0> @access_token.secret
+  => "somesecret"
 
 == Contact
 

data/Rakefile

@@ -9,6 +9,9 @@ begin
     gem.email = "robl[at]monkeyhelper.com"
     gem.homepage = "http://github.com/monkeyhelper/muddyit_fu"
     gem.authors = ["robl"]
+    gem.add_dependency('json', '>= 0.0.0')
+    gem.add_dependency('oauth', '>= 0.0.0')
+
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/muddyit/base.rb

@@ -8,12 +8,12 @@ module Muddyit
     class_attr_accessor :http_open_timeout
     class_attr_accessor :http_read_timeout
     attr_accessor :rest_endpoint
-    attr_reader :access_key_id, :secret_access_key
+    attr_reader :consumer_key, :consumer_secret, :access_token, :access_token_secret
 
-    @@http_open_timeout = 60
-    @@http_read_timeout = 60
+    @@http_open_timeout = 120
+    @@http_read_timeout = 120
 
-    REST_ENDPOINT = 'http://www.muddy.it/api'
+    REST_ENDPOINT = 'http://www.muddy.it'
 
     # Set the request signing method
     @@digest1   = OpenSSL::Digest::Digest.new("sha1")
@@ -26,10 +26,14 @@ module Muddyit
     #
     # You can either pass a hash with the following attributes:
     #
-    # * :access_key_id (Required)
-    #     the access key id
-    # * :secret_access_key (Required)
-    #     the secret access key
+    # * :consumer_key (Required)
+    #     the consumer key
+    # * :consumer_secret (Required)
+    #     the consumer secret
+    # * :access_token (Required)
+    #     the token
+    # * :access_token_secret (Required)
+    #     the token secret
     # * :rest_endpoint (Optional)
     #     the muddy.it rest service endpoint
     # or:
@@ -38,24 +42,34 @@ module Muddyit
     #
     # Config Example (yaml file)
     # ---
-    # access_key_id: YOUR_ACCESS_KEY_ID
-    # secret_access_key: YOUR_SECRET_ACCESS_KEY
+    # consumer_key: AAA
+    # consumer_secret: BBB
+    # access_token: CCC
+    # access_token_secret: DDD
     #
     def initialize(config_hash_or_file)
       if config_hash_or_file.is_a? Hash
         config_hash_or_file.nested_symbolize_keys!
-        @access_key_id = config_hash_or_file[:access_key_id]
-        @secret_access_key = config_hash_or_file[:secret_access_key]
+        @consumer_key = config_hash_or_file[:consumer_key]
+        @consumer_secret = config_hash_or_file[:consumer_secret]
+        @access_token = config_hash_or_file[:access_token]
+        @access_token_secret = config_hash_or_file[:access_token_secret]
         @rest_endpoint = config_hash_or_file.has_key?(:rest_endpoint) ? config_hash_or_file[:rest_endpoint] : REST_ENDPOINT
-        raise 'config_hash must contain access_key_id and secret_access_key' unless @access_key_id and @secret_access_key
+        raise 'config_hash must contain consumer_key and consumer_secret' unless @consumer_key and @consumer_secret
       else
         config = YAML.load_file(config_hash_or_file)
         config.nested_symbolize_keys!
-        @access_key_id = config[:access_key_id]
-        @secret_access_key = config[:secret_access_key]
+        @consumer_key = config[:consumer_key]
+        @consumer_secret = config[:consumer_secret]
+        @access_token = config[:access_token]
+        @access_token_secret = config[:access_token_secret]
         @rest_endpoint = config.has_key?(:rest_endpoint) ? config[:rest_endpoint] : REST_ENDPOINT
-        raise 'config file must contain access_key_id and secret_access_key' unless @access_key_id and @secret_access_key
+        raise 'config file must contain consumer_key and consumer_secret' unless @consumer_key and @consumer_secret
       end
+
+      @consumer = OAuth::Consumer.new(@consumer_key, @consumer_secret, {:site=>@rest_endpoint})
+      @accesstoken = OAuth::AccessToken.new(@consumer, @access_token, @access_token_secret)
+
     end
 
     # sends a request to the muddyit REST api
@@ -68,13 +82,12 @@ module Muddyit
     # * options (Optional)
     #     hash of query parameters, you do not need to include access_key_id, secret_access_key because these are added automatically
     #
-    def send_request(api_url, http_method = :get, options= {})
+    def send_request(api_url, http_method = :get, opts = {}, body = nil)
 
       raise 'no api_url supplied' unless api_url
-
-      res = request_over_http(api_url, http_method, options)
+      res = request_over_http(api_url, http_method, opts, body)
       # Strip any js wrapping methods
-      #puts res.body
+
       if res.body =~ /^.+\((.+)\)$/
         r = JSON.parse($1)
       else
@@ -91,94 +104,26 @@ module Muddyit
     protected
 
     # For easier testing. You can mock this method with a XML file you re expecting to receive
-    def request_over_http(api_url, http_method, options)
+    def request_over_http(api_url, http_method, opts, body)
 
-      req = nil
-      http_opts = { "Accept" => "application/json", "User-Agent" => "muddyit_fu" }
-      url = URI.parse(api_url)
+      http_opts = { "Accept" => "application/json", "Content-Type" => "application/json", "User-Agent" => "muddyit_fu" }
+      query_string = opts.to_a.map {|x| x.join("=")}.join("&")
 
       case http_method
         when :get
-          u = url.query.nil? ? url.path : url.path+"?"+url.query
-          req = Net::HTTP::Get.new(u, http_opts)
+          url = opts.empty? ? api_url : "#{api_url}?#{query_string}"
+          @accesstoken.get(url, http_opts)
         when :post
-          req = Net::HTTP::Post.new(url.path, http_opts)
+          @accesstoken.post(api_url, body, http_opts)
         when :put
-          req = Net::HTTP::Put.new(url.path, http_opts)
+          @accesstoken.put(api_url, body, http_opts)
         when :delete
-          req = Net::HTTP::Delete.new(url.path, http_opts)
+          @accesstoken.delete(api_url, http_opts)
       else
         raise 'invalid http method specified'
       end
-
-      options = calculate_signature(http_method, url.path, options)
-      req.set_form_data(options) unless options.keys.empty?
-      #req.basic_auth @username, @password
-
-      http = Net::HTTP.new(url.host, url.port)
-      http.open_timeout = @@http_open_timeout
-      http.read_timeout = @@http_read_timeout
-      http.start do |http|
-        res = http.request(req)
-        case res
-        when Net::HTTPSuccess
-          return res
-        else
-          raise Muddyit::Errors.error_for(res.code, 'HTTP Error')
-        end
-      end
     
     end
 
-    # aws request signature methods, taken from http://rightscale.rubyforge.org/right_aws_gem_doc
-
-    def calculate_signature(http_verb, url, options)
-      endpoint = URI.parse(@rest_endpoint)
-      options.nested_stringify_keys!
-      options.delete('Signature')
-      options['AccessKeyId'] = @access_key_id
-      options['Signature'] = sign_request_v2(@secret_access_key, options, http_verb.to_s, endpoint.host, url)
-
-      return options
-    end
-
-    def signed_service_params(aws_secret_access_key, service_hash, http_verb, host, uri)
-      sign_request_v2(aws_secret_access_key, service_hash, http_verb, host, uri)
-    end
-
-    def sign_request_v2(aws_secret_access_key, service_hash, http_verb, host, uri)
-      fix_service_params(service_hash, '2')
-      # select a signing method (make an old openssl working with sha1)
-      # make 'HmacSHA256' to be a default one
-      service_hash['SignatureMethod'] = 'HmacSHA256' unless ['HmacSHA256', 'HmacSHA1'].include?(service_hash['SignatureMethod'])
-      service_hash['SignatureMethod'] = 'HmacSHA1'   unless @@digest256
-      # select a digest
-      digest = (service_hash['SignatureMethod'] == 'HmacSHA256' ? @@digest256 : @@digest1)
-      # form string to sign
-      canonical_string = service_hash.keys.sort.map do |key|
-        "#{amz_escape(key)}=#{amz_escape(service_hash[key])}"
-      end.join('&')
-      string_to_sign = "#{http_verb.to_s.upcase}\n#{host.downcase}\n#{uri}\n#{canonical_string}"
-
-      # sign the string
-      amz_escape(Base64.encode64(OpenSSL::HMAC.digest(digest, aws_secret_access_key, string_to_sign)).strip)
-    end
-
-    # Set a timestamp and a signature version
-    def fix_service_params(service_hash, signature)
-      service_hash["Timestamp"] ||= Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.000Z") unless service_hash["Expires"]
-      service_hash["SignatureVersion"] = signature
-      service_hash
-    end
-
-    # Escape a string accordingly Amazon rulles
-    # http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/index.html?REST_RESTAuth.html
-    def amz_escape(param)
-      param.to_s.gsub(/([^a-zA-Z0-9._~-]+)/n) do
-        '%' + $1.unpack('H2' * $1.size).join('%').upcase
-      end
-    end
-
-
   end
 end

data/lib/muddyit/entity.rb

@@ -10,7 +10,7 @@ class Muddyit::Entity < Muddyit::Generic
 
   protected
   def fetch
-    api_url = "#{@muddyit.rest_endpoint}/entities/#{URI.escape(CGI.escape(@attributes[:uri]),'.')}"
+    api_url = "/entities/#{URI.escape(CGI.escape(@attributes[:uri]),'.')}"
     response = @muddyit.send_request(api_url, :get)
     response.nested_symbolize_keys!
   end

data/lib/muddyit/page.rb

@@ -12,23 +12,15 @@ class Muddyit::Sites::Site::Page < Muddyit::Generic
   # Params
   # * options (Required)
   #
-  def refresh(options)
+  def refresh(options = {})
 
     # Ensure we get content_data as well
-    options[:include_content] = true unless options.has_key?(:include_content)
+    options[:include_content] = true
 
-    # Set the URI if not set
-    options[:uri] = options[:identifier] if options.has_key?(:identifier) && !options.has_key?(:uri) && !options.has_key?(:text)
+    body = { :page => { :uri => self.uri }, :options => options }
 
-    # Ensure we have encoded the identifier and URI
-    if options.has_key?(:uri)
-      options[:uri] = URI.escape(CGI.escape(options[:uri]),'.')
-    elsif options.has_key?(:identifier)
-      options[:identifier] = URI.escape(CGI.escape(options[:identifier]),'.')
-    end
-
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(@attributes[:identifier]),'.')}/refresh"
-    response = @muddyit.send_request(api_url, :post, options)
+    api_url = "/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(self.identifier),'.')}"
+    response = @muddyit.send_request(api_url, :put, {}, body.to_json)
     return Muddyit::Sites::Site::Page.new(@muddyit, response.merge!(:site => self.site))
   end
 
@@ -51,7 +43,7 @@ class Muddyit::Sites::Site::Page < Muddyit::Generic
   # delete the page
   #
   def destroy
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(@attributes[:identifier]),'.')}"
+    api_url = "/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(@attributes[:identifier]),'.')}"
     response = @muddyit.send_request(api_url, :delete, {})
     # Is this the correct thing to return ?
     return true
@@ -63,9 +55,8 @@ class Muddyit::Sites::Site::Page < Muddyit::Generic
   # * options (Optional)
   #
   def related_content(options = {})
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(@attributes[:identifier]),'.')}/related/content"
+    api_url = "/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(@attributes[:identifier]),'.')}/related/content"
     response = @muddyit.send_request(api_url, :get, options)
-    
     results = []
     response.each { |result|
       # The return format needs sorting out here .......
@@ -76,7 +67,7 @@ class Muddyit::Sites::Site::Page < Muddyit::Generic
 
   protected
   def fetch
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(@attributes[:identifier]),'.')}"
+    api_url = "/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(@attributes[:identifier]),'.')}"
     response = @muddyit.send_request(api_url, :get, {:include_content => true })
     response.nested_symbolize_keys!
   end
@@ -84,11 +75,11 @@ class Muddyit::Sites::Site::Page < Muddyit::Generic
   # Convert results to entities
   def create_entities
     results = []
-    if @attributes.has_key?(:results)
-      @attributes[:results].each do |result|
+    if @attributes.has_key?(:entities)
+      @attributes[:entities].each do |result|
          results.push Muddyit::Entity.new(@muddyit, result)
       end
-      @attributes[:results] = results
+      @attributes[:entities] = results
     end
   end
 

data/lib/muddyit/pages.rb

@@ -12,23 +12,23 @@ class Muddyit::Sites::Site::Pages < Muddyit::Generic
     if type.is_a? Symbol
       case type
       when :all
-        api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages"
+        api_url = "/sites/#{self.site.attributes[:token]}/pages"
         if block_given?
           token = nil
           begin
           response = @muddyit.send_request(api_url, :get, options.merge!(:page => token))
-          response['resultsets'].each { |page|
+          response['pages'].each { |page|
             yield Muddyit::Sites::Site::Page.new(@muddyit, page.merge!(:site => self.site))
           }
           token = response['next_page']
           # Need to figure out which of the below actually occurs
           end while !token.nil? || !token == ''
         else
-          api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages"
+          api_url = "/sites/#{self.site.attributes[:token]}/pages"
           response = @muddyit.send_request(api_url, :get, options)
 
           pages = []
-          response['resultsets'].each { |page| pages.push Muddyit::Sites::Site::Page.new(@muddyit, page.merge!(:site => self.site)) }
+          response['pages'].each { |page| pages.push Muddyit::Sites::Site::Page.new(@muddyit, page.merge!(:site => self.site)) }
           return { :next_page => response['next_page'], :pages => pages }
         end
       else
@@ -36,9 +36,9 @@ class Muddyit::Sites::Site::Pages < Muddyit::Generic
       end
 
     elsif type.is_a? String
-      api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(type),'.')}"
+      api_url = "/sites/#{self.site.attributes[:token]}/pages/#{URI.escape(CGI.escape(type),'.')}"
       response = @muddyit.send_request(api_url, :get, {})
-      response.has_key?('results') ? Muddyit::Sites::Site::Page.new(@muddyit, response.merge!(:site => self.site)) : nil
+      response.has_key?('identifier') ? Muddyit::Sites::Site::Page.new(@muddyit, response.merge!(:site => self.site)) : nil
     end
   end
 
@@ -49,7 +49,7 @@ class Muddyit::Sites::Site::Pages < Muddyit::Generic
   #
   def related_entities(uri, options = {})
     raise "no uri supplied" if uri.nil?
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/related/entities/#{URI.escape(CGI.escape(uri),'.')}"
+    api_url = "/sites/#{self.site.attributes[:token]}/related/entities/#{URI.escape(CGI.escape(uri),'.')}"
     response = @muddyit.send_request(api_url, :get, options)
 
     results = []
@@ -65,25 +65,20 @@ class Muddyit::Sites::Site::Pages < Muddyit::Generic
   # Params
   # * options (Required)
   #
-  def categorise(options)
+  def categorise(doc = {}, options = {})
 
     # Ensure we get content_data as well
     options[:include_content] = true
 
-    # Set the URI if not set
-    options[:uri] = options[:identifier] if options.has_key?(:identifier) && !options.has_key?(:uri) && !options.has_key?(:text)
-
     # Ensure we have encoded the identifier and URI
-    if options.has_key?(:uri)
-      raise if options[:uri].nil?
-      options[:uri] = URI.escape(CGI.escape(options[:uri]),'.')
-    elsif options.has_key?(:identifier)
-      raise if options[:identifier].nil?
-      options[:identifier] = URI.escape(CGI.escape(options[:identifier]),'.')
+    unless doc[:uri] || doc[:text]
+      raise
     end
 
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/categorise"
-    response = @muddyit.send_request(api_url, :post, options)
+    body = { :page => doc, :options => options }
+
+    api_url = "/sites/#{self.site.attributes[:token]}/pages/"
+    response = @muddyit.send_request(api_url, :post, {}, body.to_json)
     return Muddyit::Sites::Site::Page.new(@muddyit, response.merge!(:site => self.site))
   end
 
@@ -146,7 +141,7 @@ class Muddyit::Sites::Site::Pages < Muddyit::Generic
   #     must contain uri parameter which corresponds to dbpedia uri
   #
   def queryAllWithURI(uri, options, &block)
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/withentities/#{URI.escape(CGI.escape(uri),'.')}"
+    api_url = "/sites/#{self.site.attributes[:token]}/entities/#{URI.escape(CGI.escape(uri),'.')}"
     query_page(api_url, options, &block)
   end
 
@@ -159,7 +154,7 @@ class Muddyit::Sites::Site::Pages < Muddyit::Generic
   #
   #
   def queryAllWithTerm(term, options, &block)
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{self.site.attributes[:token]}/pages/withterms/#{URI.escape(CGI.escape(term),'.')}"
+    api_url = "/sites/#{self.site.attributes[:token]}/terms/#{URI.escape(CGI.escape(term),'.')}"
     query_page(api_url, options, &block)
   end
 
@@ -174,8 +169,8 @@ class Muddyit::Sites::Site::Pages < Muddyit::Generic
       token = nil
       begin
         options.merge!(:page => token) unless token.nil?
-        response = @muddyit.send_request(api_url, :get, options)
-        response['resultsets'].each { |page|
+        response = @muddyit.send_request(api_url, :get, options.merge!(:page => token))
+        response['pages'].each { |page|
           yield Muddyit::Sites::Site::Page.new(@muddyit, page.merge!(:site => self.site))
         }
         token = response['next_page']
@@ -185,7 +180,7 @@ class Muddyit::Sites::Site::Pages < Muddyit::Generic
       response = @muddyit.send_request(api_url, :get, {})
 
       pages = []
-      response['resultsets'].each { |page| pages.push Muddyit::Sites::Site::Page.new(@muddyit, page.merge!(:site => self.site)) }
+      response['pages'].each { |page| pages.push Muddyit::Sites::Site::Page.new(@muddyit, page.merge!(:site => self.site)) }
       return { :next_page => response[:next_page], :pages => pages }
     end    
   end

data/lib/muddyit/site.rb

@@ -6,7 +6,7 @@ class Muddyit::Sites::Site < Muddyit::Generic
   
   protected
   def fetch
-    api_url = "#{@muddyit.rest_endpoint}/sites/#{@attributes[:token]}"
+    api_url = "/sites/#{@attributes[:token]}"
     response = @muddyit.send_request(api_url, :get, {})
     response['site'].nested_symbolize_keys!
   end

data/lib/muddyit/sites.rb

@@ -24,7 +24,7 @@ class Muddyit::Sites < Muddyit::Base
     if type.is_a? Symbol
       case type
       when :all
-        api_url = "#{@muddyit.rest_endpoint}/sites/"
+        api_url = "/sites/"
         response = @muddyit.send_request(api_url, :get, options)
         sites = []
         response.each { |site| sites.push Muddyit::Sites::Site.new(@muddyit, site['site']) }
@@ -33,7 +33,7 @@ class Muddyit::Sites < Muddyit::Base
         raise 'invalid type specified'
       end
     elsif type.is_a? String
-      api_url = "#{@muddyit.rest_endpoint}/sites/#{type}"
+      api_url = "/sites/#{type}"
       response = @muddyit.send_request(api_url, :get, options)
       return Muddyit::Sites::Site.new(@muddyit, response['site'])
     else

data/lib/muddyit_fu.rb

@@ -3,8 +3,7 @@ require 'net/http'
 require 'cgi'
 require 'json'
 #require 'json/ext'
-require 'openssl'
-require 'base64' 
+require 'oauth/consumer'
 
 require 'pp'
 

data/muddyit_fu.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{muddyit_fu}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["robl"]
-  s.date = %q{2009-06-03}
+  s.date = %q{2009-06-23}
   s.email = %q{robl[at]monkeyhelper.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -31,20 +31,25 @@ Gem::Specification.new do |s|
      "lib/muddyit_fu.rb",
      "muddyit_fu.gemspec"
   ]
-  s.has_rdoc = true
   s.homepage = %q{http://github.com/monkeyhelper/muddyit_fu}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.1}
+  s.rubygems_version = %q{1.3.4}
   s.summary = %q{Provides a ruby interface to muddy.it}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 0.0.0"])
+      s.add_runtime_dependency(%q<oauth>, [">= 0.0.0"])
     else
+      s.add_dependency(%q<json>, [">= 0.0.0"])
+      s.add_dependency(%q<oauth>, [">= 0.0.0"])
     end
   else
+    s.add_dependency(%q<json>, [">= 0.0.0"])
+    s.add_dependency(%q<oauth>, [">= 0.0.0"])
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: monkeyhelper-muddyit_fu
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - robl
@@ -9,10 +9,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-03 00:00:00 -07:00
+date: 2009-06-23 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
 description: 
 email: robl[at]monkeyhelper.com
 executables: []
@@ -40,7 +59,7 @@ files:
 - lib/muddyit/sites.rb
 - lib/muddyit_fu.rb
 - muddyit_fu.gemspec
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/monkeyhelper/muddyit_fu
 post_install_message: 
 rdoc_options: 
@@ -64,7 +83,7 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Provides a ruby interface to muddy.it
 test_files: []