muddyit_fu 0.2.9 → 0.2.10

data/VERSION

@@ -1 +1 @@
-0.2.9
+0.2.10

data/lib/muddyit/base.rb

@@ -8,7 +8,7 @@ module Muddyit
     class_attr_accessor :http_open_timeout
     class_attr_accessor :http_read_timeout
     attr_accessor :rest_endpoint
-    attr_reader :consumer_key, :consumer_secret, :access_token, :access_token_secret
+    attr_reader :consumer_key, :consumer_secret, :access_token, :access_token_secret, :username, :password, :auth_type
 
     @@http_open_timeout = 120
     @@http_read_timeout = 120
@@ -50,25 +50,34 @@ module Muddyit
     def initialize(config_hash_or_file)
       if config_hash_or_file.is_a? Hash
         config_hash_or_file.nested_symbolize_keys!
+        @username = config_hash_or_file[:username]
+        @password = config_hash_or_file[:password]
         @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 consumer_key and consumer_secret' unless @consumer_key and @consumer_secret
       else
         config = YAML.load_file(config_hash_or_file)
         config.nested_symbolize_keys!
+        @username = config[:username]
+        @password = config[:password]
         @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 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)
+      if !@consumer_key.nil?
+        @auth_type = :oauth
+        @consumer = ::OAuth::Consumer.new(@consumer_key, @consumer_secret, {:site=>@rest_endpoint})
+        @accesstoken = ::OAuth::AccessToken.new(@consumer, @access_token, @access_token_secret)
+      elsif !@username.nil?
+        @auth_type = :basic
+      else
+        raise "unable to find authentication credentials"
+      end
 
     end
 
@@ -85,8 +94,14 @@ module Muddyit
     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, opts, body)
-      # Strip any js wrapping methods
+      
+      res = nil
+      case @auth_type
+      when :oauth
+        res = oauth_request_over_http(api_url, http_method, opts, body)
+      when :basic
+        res = basic_request_over_http(api_url, http_method, opts, body)
+      end
 
       case res
       when Net::HTTPSuccess, Net::HTTPRedirection
@@ -94,6 +109,7 @@ module Muddyit
         when " "
           return res
         when /^.+\((.+)\)$/
+          # Strip any js callback method
           return JSON.parse($1)
         else
           return JSON.parse(res.body)
@@ -108,10 +124,29 @@ module Muddyit
     # creates and/or returns the Muddyit::Collections object
     def collections() @collections ||= Muddyit::Collections.new(self) end
 
+    # A mirror of the pages.create method, but for one off, non-stored, quick extraction
+    def extract(doc={}, options={})
+
+      # Ensure we get content_data as well
+      options[:include_content] = true
+
+      # Ensure we have encoded the identifier and URI
+      unless doc[:uri] || doc[:text]
+        raise
+      end
+
+      body = { :page => doc.merge!(:options => options) }
+
+      api_url = "/extract"
+      response = self.send_request(api_url, :post, {}, body.to_json)
+      return Muddyit::Collections::Collection::Pages::Page.new(self, response)
+
+    end
+    
     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, opts, body)
+    def oauth_request_over_http(api_url, http_method, opts, body)
 
       http_opts = { "Accept" => "application/json", "Content-Type" => "application/json", "User-Agent" => "muddyit_fu" }
       query_string = opts.to_a.map {|x| x.join("=")}.join("&")
@@ -129,7 +164,65 @@ module Muddyit
       else
         raise 'invalid http method specified'
       end
-    
+    end
+
+    def basic_request_over_http(path, http_method, opts, data)
+
+      http_opts = { "Accept" => "application/json", "Content-Type" => "application/json", "User-Agent" => "muddyit_fu" }
+      query_string = opts.to_a.map {|x| x.join("=")}.join("&")
+
+      u = URI.parse(@rest_endpoint+path)
+
+      if [:post, :put].include?(http_method)
+        data.reject! { |k,v| v.nil? } if data.is_a?(Hash)
+      end
+
+      headers = http_opts
+
+      case http_method
+      when :post
+        request = Net::HTTP::Post.new(path,headers)
+        request.basic_auth @username, @password
+        request["Content-Length"] = 0 # Default to 0
+      when :put
+        request = Net::HTTP::Put.new(path,headers)
+        request.basic_auth @username, @password
+        request["Content-Length"] = 0 # Default to 0
+      when :get
+        request = Net::HTTP::Get.new(path,headers)
+        request.basic_auth @username, @password
+      when :delete
+        request =  Net::HTTP::Delete.new(path,headers)
+        request.basic_auth @username, @password
+      when :head
+        request = Net::HTTP::Head.new(path,headers)
+        request.basic_auth @username, @password
+      else
+        raise ArgumentError, "Don't know how to handle http_method: :#{http_method.to_s}"
+      end
+
+      if data.is_a?(Hash)
+        request.set_form_data(data)
+      elsif data
+        if data.respond_to?(:read)
+          request.body_stream = data
+          if data.respond_to?(:length)
+            request["Content-Length"] = data.length
+          elsif data.respond_to?(:stat) && data.stat.respond_to?(:size)
+            request["Content-Length"] = data.stat.size
+          else
+            raise ArgumentError, "Don't know how to send a body_stream that doesn't respond to .length or .stat.size"
+          end
+        else
+          request.body = data.to_s
+          request["Content-Length"] = request.body.length
+        end
+      end
+
+      http = Net::HTTP.new(u.host, u.port)
+      #http.open_timeout = self.http_open_timeout unless self.http_open_timeout.nil?
+      #http.read_timeout = self.http_read_timeout unless self.http_read_timeout.nil?
+      http.start { |http| http.request(request) }
     end
 
   end

data/muddyit_fu.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{muddyit_fu}
-  s.version = "0.2.9"
+  s.version = "0.2.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["rattle"]
-  s.date = %q{2010-01-09}
+  s.date = %q{2010-01-11}
   s.email = %q{support[at]muddy.it}
   s.extra_rdoc_files = [
     "LICENSE",

data/test/test_muddyit_fu.rb

@@ -15,12 +15,19 @@ class TestMuddyitFu < Test::Unit::TestCase
                              :consumer_secret => c['consumer_secret'],
                              :access_token => c['access_token'],
                              :access_token_secret => c['access_token_secret'],
-                             :rest_endpoint => c['rest_endpoint'])
+                             :rest_endpoint => c['rest_endpoint'],
+                             :username => c['username'],
+                             :password => c['password'])
       rescue
         puts "Failed to connect to muddy, are the details correct ?"
       end
     end
 
+    should "analyse a page without a collection" do
+      page = @muddyit.extract({:uri => @@STORY})
+      assert page.entities.length > 0
+    end
+
     should 'be able to create a collection' do
       collection = @muddyit.collections.create(@@COLLECTION_LABEL, 'http://www.test.com')
       assert !collection.token.nil?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: muddyit_fu
 version: !ruby/object:Gem::Version 
-  version: 0.2.9
+  version: 0.2.10
 platform: ruby
 authors: 
 - rattle
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-09 00:00:00 +00:00
+date: 2010-01-11 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency