openamplify 0.1.1 → 0.2.0

data/History

@@ -0,0 +1,5 @@
+0.2.0 - June 11, 2010
+      * added helpers to topic results
+      * added post method
+0.1.1 - improved the notes
+0.1.0 - initial release

data/README.rdoc

@@ -36,6 +36,12 @@ monitoring the tone of forum threads.
   # 'response' works like a Hash
   puts response['Topics']
 
+  # or use the shortcuts
+  response.top_topics
+  response.proper_nouns
+  response.locations
+  response.domains
+
 === Output Format
 
 In case you need a different format, OpenAmplify supports XML, JSON, RDF, CSV.
@@ -68,6 +74,15 @@ The different options and explanations are available at http://community.openamp
   response['Topics']  # => should be another big Hash of key-value pairs
   response['Demographics'] # => nil
 
+=== POST method
+
+By default, GET is used. If you need to analyze lots of text, use POST
+
+  client = OpenAmplify::Client.new(:api_key => API_KEY, :method => :post)
+
+  # or
+  client.method = :post
+  
 === Request URL
 
 In case you are wondering what the request URL looks like:

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :major: 0
-:minor: 1
+:minor: 2
 :build: 
-:patch: 1
+:patch: 0

data/lib/openamplify.rb

@@ -6,16 +6,17 @@ module OpenAmplify
   API_URL = "http://portaltnx20.openamplify.com/AmplifyWeb_v20/AmplifyThis"
 
   class Client
-    def initialize(options)
-      @options = { :base_url => API_URL }
+    def initialize(options={})
+      @options = { :base_url => API_URL, :method => :get }
       @options.merge!(OpenAmplify.symbolize_keys(options))
     end
 
     def analyze_text(text)
-      Response.new(:base_url => @options[:base_url], :query => query.merge(:inputText => text))
+      Response.new(:base_url => @options[:base_url], :query => query.merge(:inputText => text), 
+                   :method => @options[:method])
     end
     
-    %w(api_key analysis base_url).each do |attr|
+    %w(api_key analysis base_url method).each do |attr|
       class_eval <<-EOS
         def #{attr}
           @options[:#{attr}]
@@ -49,50 +50,64 @@ module OpenAmplify
       @request_url ||= compose_url(@options[:base_url], @options[:query]) 
     end
     
-    def response
-      @response ||= get_response
-    end
-  
-    # Make this class behave like a Hash
-    # TODO: Add more methods
-    
     def each
       response.each do |k, v|
         yield(k, v)
       end
     end
-    
-    ['has_key?', '==', '[]', 'fetch', 'empty?', 'include?', 'inspect', 
-      'key?', 'keys', 'length', 'member?', 'merge', 'merge!'
-    ].each do |method|
-      class_eval <<-EOS
-        def #{method}(*args)
-          response.send('#{method}', *args)
-        end
-      EOS
+
+    def method_missing(name, *args, &block)
+      response.send(name, *args, &block)
     end
-    ## Hash methods end here
-    
+     
     # Support the different formats. Note this would entail another request
     # to openamplify
     %w(xml json rdf csv oas signals pretty).each do |format|
       class_eval <<-EOS
         def to_#{format}
-          get('#{format}')
+          fetch_as_format(:#{format})
         end
       EOS
     end
 
-    private
+    def top_topics
+      items = response && response['Topics']['TopTopics']
+    end
 
+    def proper_nouns
+      items = response && response['Topics']['ProperNouns']
+
+      return items if items.is_a?(Array)
+
+      # I'm not sure if this is the default behavior if
+      # only a single item is found, or if it is a bug
+      # TODO: check other helpers as well
+      if items.is_a?(Hash)
+        return [ items['TopicResult'] ]
+      end
+    end
+
+    def locations
+      response && response['Topics']['Locations']
+    end
+
+    def domains
+      response && response['Topics']['Domains']
+    end
+
+    private
     def compose_url(path, params)
       path + '?' + URI.escape(params.collect{ |k, v| "#{k}=#{v}" }.join('&'))
     end
+
+    def response
+      @response ||= fetch_response
+    end
   
-    def get_response
-      response = get('json') 
+    def fetch_response
+      response = fetch_as_format(:json)
       result   = JSON.parse(response)
-     
+
       if analysis = @options[:query][:analysis]
         name = analysis.sub(/./){ |s| s.upcase }
         result["ns1:#{name}Response"]["#{name}Return"]
@@ -101,12 +116,24 @@ module OpenAmplify
       end
     end
 
-    def get(format)
-      params = @options[:query]
-      url    = compose_url(@options[:base_url], params.merge(:outputFormat => format))
+    def fetch_as_format(format)
+      fetch(@options[:base_url], @options[:query].merge(:outputFormat => format), @options[:method])
+    end
+
+    def fetch(path, params, method)
+      self.send(method, path, params)
+    end
+
+    def get(path, params)
+      url = compose_url(path, params)
       Net::HTTP.get_response(URI.parse(url)).body
     end
 
+    def post(path, params)
+      uri = URI::parse(path)
+      Net::HTTP.post_form(uri, params).body
+    end
+
   end # OpenAmplify::Response
 
   private 

data/openamplify.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{openamplify}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Greg Moreno"]
-  s.date = %q{2010-06-05}
+  s.date = %q{2010-06-11}
   s.description = %q{The OpenAmplify API reads text you supply and returns linguistic data explaining and classifying the content.}
   s.email = %q{rubyoncloud@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: openamplify
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Greg Moreno
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-05 00:00:00 -07:00
+date: 2010-06-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency