pius-ruby-satisfaction 0.3.0

data/.gemified

@@ -0,0 +1,12 @@
+--- 
+:author: Scott Fleckenstein
+:dependencies: 
+- rspec
+- oauth
+- memcache-client
+- "activesupport"
+:version: 0.2.0
+:name: ruby-satisfaction
+:summary: Helper gem for the getsatisfaction.com API
+:email: nullstyle@gmail.com
+:homepage: http://nullstyle.com

data/.gitignore

@@ -0,0 +1,3 @@
+tmp/*
+log/*
+pkg

data/CONTRIBUTORS.txt

@@ -0,0 +1,7 @@
+John Duff
+
+
+Awards
+======
+
+John Duff gets the "Getting the ball rolling" achievement award for being the first contributor besides myself.

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Scott Fleckenstein
+
+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/README.txt

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

data/Rakefile

@@ -0,0 +1,14 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "ruby-satisfaction"
+    gemspec.summary = "Ruby interface to Get Satisfaction"
+    gemspec.description = "Ruby interface to Get Satisfaction"
+    gemspec.email = "scott@getsatisfaction.com"
+    gemspec.homepage = "http://github.com/pius/ruby-satisfaction"
+    gemspec.authors = ["Scott Fleckenstein", "Josh Nichols", "Pius Uzamere"]
+    VERSION = '0.3.0'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/init.rb

@@ -0,0 +1 @@
+require 'satisfaction'

data/lib/satisfaction/associations.rb

@@ -0,0 +1,20 @@
+module Associations
+  def has_many(resource, options={})
+    class_name = options[:class_name] || "Sfn::#{resource.to_s.classify}"
+    eval <<-EOS
+      def #{resource}
+        @#{resource} ||= Sfn::ResourceCollection.new(#{class_name}, self.satisfaction, '#{options[:url]}')
+      end
+    EOS
+  end
+  
+  def belongs_to(resource, options={})
+    class_name = options[:class_name] || "Sfn::#{resource.to_s.classify}"
+    parent_id = options[:parent_attribute] || "#{resource}_id"
+    eval <<-EOS
+      def #{resource}
+        @#{resource} ||= #{class_name}.new(#{parent_id}, self.satisfaction)
+      end
+    EOS
+  end
+end

data/lib/satisfaction/cache/hash.rb

@@ -0,0 +1,14 @@
+class Sfn::Loader::HashCache
+  def initialize
+    @cached_responses = {}
+  end
+  
+  def put(url, response)
+    return nil if response["ETag"].blank?
+    @cached_responses[url.to_s] = Sfn::Loader::CacheRecord.new(url, response["ETag"], response.body)
+  end
+  
+  def get(url)
+    @cached_responses[url.to_s]
+  end
+end

data/lib/satisfaction/cache/memcache.rb

@@ -0,0 +1,17 @@
+
+class Sfn::Loader::MemcacheCache
+  def initialize(options = {})
+    options = options.reverse_merge({:servers => ['127.0.0.1:11211'], :namespace => 'satisfaction', })
+    @m = MemCache.new(options.delete(:servers), options)
+  end
+  
+  def put(url, response)
+    return nil if response["ETag"].blank?
+    
+    @m[url.to_s] = Sfn::Loader::CacheRecord.new(url, response["ETag"], response.body)
+  end
+  
+  def get(url)
+    @m[url.to_s]
+  end
+end

data/lib/satisfaction/company.rb

@@ -0,0 +1,18 @@
+class Sfn::Company < Sfn::Resource
+  
+  attributes :domain, :name, :logo, :description
+  
+  def path
+    "/companies/#{@id}"
+  end
+  
+  def setup_associations
+    has_many :people, :url => "#{path}/people"
+    has_many :topics, :url => "#{path}/topics"
+    has_many :products, :url => "#{path}/products"
+    has_many :employees, :url => "#{path}/employees", :class_name => 'Sfn::Person'
+    has_many :tags, :url => "#{path}/tags"
+    
+  end
+  
+end

data/lib/satisfaction/external_dependencies.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'active_support'
+require 'hpricot'
+require 'json'
+require 'json/add/rails'  #make json play nice with the json rails outputs
+gem('memcache-client')
+require 'memcache'
+
+require 'oauth'
+require 'oauth/signature/hmac/sha1'
+require 'oauth/client/net_http'

data/lib/satisfaction/has_satisfaction.rb

@@ -0,0 +1,8 @@
+class Sfn::HasSatisfaction
+  attr_reader :satisfaction
+  
+  def initialize(satisfaction)
+    @satisfaction = satisfaction
+  end
+  
+end

data/lib/satisfaction/identity_map.rb

@@ -0,0 +1,21 @@
+class Sfn::IdentityMap
+  attr_reader :records, :pages
+  
+  def initialize
+    @records = {}
+    @pages = {}
+  end
+  
+  def get_record(klass, id, &block)
+    result = @records[[klass, id]]
+    result ||= begin
+      obj = yield(klass, id)
+      @records[[klass, id]] = obj
+    end
+    result
+  end
+  
+  def expire_record(klass, id)
+    @records[[klass, id]] = nil
+  end
+end

data/lib/satisfaction/loader.rb

@@ -0,0 +1,115 @@
+require 'net/http'
+require 'uri'
+
+
+class Sfn::Loader
+  require 'satisfaction/cache/hash'
+  require 'satisfaction/cache/memcache'
+
+  CacheRecord = Struct.new(:url, :etag, :body)
+  attr_reader :cache
+  attr_reader :options
+  
+  def initialize(options={})
+    @options = options.reverse_merge({:cache => :hash})
+    reset_cache
+  end
+  
+  def reset_cache
+    @cache =  case @options[:cache]
+              when :hash then HashCache.new
+              when :memcache then MemcacheCache.new(@options[:memcache] || {})
+              else
+                raise ArgumentError, "Invalid cache spec: #{@options[:cache]}"
+              end
+  end
+  
+  def get(url, options = {})
+    uri = get_uri(url)
+    request = Net::HTTP::Get.new(uri.request_uri)
+    cache_record = cache.get(uri)
+    
+    if cache_record && !options[:force]
+      request["If-None-Match"] = cache_record.etag
+    end
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    add_authentication(request, http, options)
+    response = execute(http, request)
+    
+    case response
+    when Net::HTTPNotModified
+      return [:ok, cache_record.body]
+    when Net::HTTPSuccess
+      cache.put(uri, response)
+      [:ok, response.body]
+    when Net::HTTPMovedPermanently
+      limit = options[:redirect_limit] || 3
+      raise ArgumentError, "Too many redirects" unless limit > 0 #TODO: what is a better error here?
+      get(response['location'], options.merge(:redirect_limit => limit - 1))
+    when Net::HTTPBadRequest
+      [:bad_request, response.body]
+    when Net::HTTPForbidden
+      [:forbidden, response.body]
+    when Net::HTTPUnauthorized
+      [:unauthorized, response.body]
+    else
+      raise "Explode: #{response.to_yaml}"
+    end
+  end
+  
+  def post(url, options)
+    uri = get_uri(url)
+    form = options[:form] || {}
+    method_klass =  case options[:method]
+                    when :put     then Net::HTTP::Put
+                    when :delete  then Net::HTTP::Delete
+                    else
+                       Net::HTTP::Post
+                    end
+                    
+    request = method_klass.new(uri.request_uri)
+    
+    request.set_form_data(form)
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    add_authentication(request, http, options)
+    response = execute(http, request)
+    
+    case response
+    when Net::HTTPUnauthorized
+      [:unauthorized, response.body]
+    when Net::HTTPBadRequest
+      [:bad_request, response.body]
+    when Net::HTTPForbidden
+      [:forbidden, response.body]
+    when Net::HTTPSuccess
+      [:ok, response.body]
+    else
+      raise "Explode: #{response.to_yaml}"
+    end
+  end
+  
+  private
+  def execute(http, request)
+    http.start{|http| http.request(request) }
+  end
+  
+  def get_uri(url)
+    case url
+    when URI then url
+    when String then URI.parse(url)
+    else
+      raise ArgumentError, "Invalid uri, please use a String or URI object"
+    end
+  end
+  
+  def add_authentication(request, http, options)
+    if options[:user]
+      request.basic_auth(options[:user], options[:password])
+    elsif options[:consumer]
+      request.oauth!(http, options[:consumer], options[:token])
+    end
+  end
+end
+

data/lib/satisfaction/person.rb

@@ -0,0 +1,24 @@
+class Sfn::Person < Sfn::Resource
+  attributes :name, :id, :photo, :tagline
+  
+  def path
+    "/people/#{@id}"
+  end
+  
+  def setup_associations
+    has_many :replies, :url => "#{path}/replies"
+    has_many :topics, :url => "#{path}/topics"
+    has_many :followed_topics, :url => "#{path}/followed/topics", :class_name => 'Sfn::Topic'
+  end
+end
+
+class Me < Sfn::Person  
+  def path
+    loaded? ? super : "/me"
+  end
+  
+  def was_loaded(result)
+    @id = self.attributes["id"]
+    setup_associations
+  end
+end

data/lib/satisfaction/product.rb

@@ -0,0 +1,17 @@
+class Sfn::Product < Sfn::Resource
+  attributes :name, :url, :image, :description
+  attribute :last_active_at, :type => Time
+  attribute :created_at, :type => Time
+  
+  def path
+    "/products/#{@id}"
+  end
+  
+  def setup_associations
+    has_many :topics, :url => "#{path}/topics"
+    has_many :people, :url => "#{path}/people"
+    has_many :companies, :url => "#{path}/companies"
+    has_many :tags, :url => "#{path}/tags"
+  end
+
+end

data/lib/satisfaction/reply.rb

@@ -0,0 +1,13 @@
+class Sfn::Reply < Sfn::Resource
+  attributes :content, :star_count, :topic_id
+  attribute :created_at, :type => Time
+  attribute :author, :type => Sfn::Person
+  
+  def path
+    "/replies/#{id}"
+  end
+  
+  def setup_associations
+    belongs_to :topic
+  end
+end

data/lib/satisfaction/resource/attributes.rb

@@ -0,0 +1,67 @@
+module Sfn::Resource::Attributes
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      include InstanceMethods
+      attr_reader :attributes
+    end
+  end
+  
+  module ClassMethods
+
+    def attributes(*names)
+      options = names.extract_options!
+      
+      names.each do |name|
+        attribute name, options unless name.blank?
+      end
+    end
+
+    def attribute(name, options)
+      options.reverse_merge!(:type => 'nil')
+      raise "Name can't be empty" if name.blank?
+      
+      class_eval <<-EOS
+        def #{name}
+          self.load unless self.loaded?
+          @#{name} ||= decode_raw_attribute(@attributes['#{name}'], #{options[:type]}) if @attributes
+        end
+      EOS
+    end
+  
+  end
+  
+  module InstanceMethods
+    def attributes=(value) 
+      @attributes = value.with_indifferent_access
+    end
+    
+    private
+    def decode_raw_attribute(value, type)
+      if type.respond_to?(:decode_sfn)
+        type.decode_sfn(value, self.satisfaction)
+      else
+        value
+      end
+    end
+  end
+end
+
+
+class Time
+  def self.decode_sfn(value, satisfaction)
+    parse(value)
+  end
+end
+
+class Sfn::Resource
+  def self.decode_sfn(value, satisfaction)
+    case value
+    when Hash
+      id = value['id']
+      returning(new(id, satisfaction)){|r| r.attributes = value}
+    else
+      new(value, satisfaction)
+    end
+  end
+end

data/lib/satisfaction/resource.rb

@@ -0,0 +1,208 @@
+require 'forwardable'
+
+class Sfn::Resource < Sfn::HasSatisfaction
+  require 'satisfaction/resource/attributes'
+  include ::Associations
+  include Attributes
+  attr_reader :id
+  include Sfn::Util
+  
+  
+  def initialize(id, satisfaction)
+    super satisfaction
+    @id = id
+    setup_associations if respond_to?(:setup_associations)
+  end
+  
+  def path
+    raise "path not implemented in Resource base class"
+  end
+  
+  def load
+    result = satisfaction.get("#{path}.json")
+    
+    if result.first == :ok
+      self.attributes = JSON.parse(result.last)
+      was_loaded(result.last)
+      self
+    else
+      result
+    end
+  end
+  
+  def was_loaded(result)
+    #override this to augment post-loading behavior
+  end
+  
+  def delete
+    satisfaction.delete("#{path}.json")
+  end
+  
+  def put(attrs)
+    params = requestify(attrs, self.class.name.underscore)
+    result = satisfaction.put("#{path}.json", params)
+    
+    if result.first == :ok
+      json = JSON.parse(result.last)
+      self.attributes = json
+      self
+    else
+      result
+    end
+  end
+  
+  def loaded?
+    !@attributes.nil?
+  end
+  
+  def inspect
+    if loaded?
+      "<#{self.class.name} #{attributes.map{|k,v| "#{k}: #{v}"}.join(' ') if !attributes.nil?}>"
+    else
+      "<#{self.class.name} #{path} UNLOADED>"      
+    end
+  end
+
+end
+
+class Sfn::ResourceCollection < Sfn::HasSatisfaction
+  attr_reader :klass
+  attr_reader :path
+  include Sfn::Util
+  
+  def initialize(klass, satisfaction, path)
+    super satisfaction
+    @klass = klass
+    @path = path
+  end
+  
+  def page(number, options={})
+    Sfn::Page.new(self, number, options)
+  end
+  
+  def get(id, options={})
+    #options currently ignored
+    satisfaction.identity_map.get_record(klass, id) do
+      klass.new(id, satisfaction)
+    end
+  end
+  
+  def post(attrs)
+    params = requestify(attrs, klass.name.underscore)
+    result = satisfaction.post("#{path}.json", params)
+    
+    if result.first == :ok
+      json = JSON.parse(result.last)
+      id = json["id"]
+      obj = klass.new(id, satisfaction)
+      obj.attributes = json
+      obj
+    else
+      result
+    end
+  end
+  
+  def [](*key)
+    options = key.extract_options!
+    case key.length
+    when 1
+      get(key, options)
+    when 2
+      page(key.first, options.merge(:limit => key.last))
+    else
+      raise ArgumentError, "Invalid Array arguement, only use 2-element array: :first is the page number, :last is the page size"
+    end
+  end
+  
+end
+
+class Sfn::Page < Sfn::HasSatisfaction
+  attr_reader :total
+  attr_reader :collection
+  
+  extend Forwardable
+  def_delegator :items, :first
+  def_delegator :items, :last
+  def_delegator :items, :each
+  def_delegator :items, :each_with_index    
+  def_delegator :items, :inject    
+  def_delegator :items, :reject    
+  def_delegator :items, :select    
+  def_delegator :items, :map
+  def_delegator :items, :[]
+  def_delegator :items, :length
+  def_delegator :items, :to_a
+  def_delegator :items, :empty?
+  
+  def initialize(collection, page, options={})
+    super(collection.satisfaction)
+    @collection = collection
+    @klass = collection.klass
+    @page = page
+    @path = collection.path
+    @options = options
+    @options[:limit] ||= 10
+  end
+  
+  # Retrieve the items for this page
+  # * Caches
+  def items
+    load
+    @data
+  end
+  
+  def loaded?
+    !@data.nil?
+  end
+  
+  def page_size
+    @options[:limit]
+  end
+  
+  def next?
+    load #this loads the data, we shold probably make load set the ivar instead of items ;)
+    last_item = @page * page_size
+    @total > last_item
+  end
+  
+  def next
+    return nil unless next?
+    self.class.new(@collection, @page + 1, @options)
+  end
+  
+  
+  def prev?
+    @page > 1
+  end
+  
+  def prev
+    return nil unless prev?
+    self.class.new(@collection, @page - 1, @options)
+  end
+  
+  def page_count
+    result = @total / length
+    result += 1 if @total % length != 0
+    result
+  end
+  
+  def load(force=false)
+    return @data if loaded? && !force
+        
+    result = satisfaction.get("#{@path}.json", @options.merge(:page => @page))
+    
+    if result.first == :ok
+      json = JSON.parse(result.last)
+      @total = json["total"]
+    
+      @data = json["data"].map do |result|
+        obj = @klass.decode_sfn(result, satisfaction)
+        satisfaction.identity_map.get_record(@klass, obj.id) do
+          obj
+        end
+      end
+    else
+      result
+    end
+  end
+end

data/lib/satisfaction/search.rb

@@ -0,0 +1,23 @@
+class Sfn::Search
+  attr_reader :results, :root_url, :loader
+  
+  def initialize(root_url, loader)
+    @root_url = root_url
+    @loader = loader
+    @results = {}
+  end
+  
+  def for_likely_matches_to(name, entities = %w(companies products))
+    @results = entities.inject({}) {|hash, entity|
+      query_string = "#{@root_url}/#{entity}.json?q=#{name}"
+      #result = Net::HTTP.get_response(URI.parse(query_string)).body
+      answer = @loader.get(query_string)
+      if answer[0] == :ok
+        result = answer[1]
+        hash.merge({entity => JSON.parse(result)})
+      else
+        raise "Search service not available at the moment, please try again later."
+      end
+    }
+  end
+end

data/lib/satisfaction/tag.rb

@@ -0,0 +1,14 @@
+class Sfn::Tag < Sfn::Resource
+  attributes :name
+
+  def path
+    "/tags/#{@id}"
+  end
+  
+  def setup_associations
+    has_many :topics, :url => "#{path}/topics"
+    has_many :companies, :url => "#{path}/companies"
+    has_many :products, :url => "#{path}/products"
+  end
+
+end

data/lib/satisfaction/topic.rb

@@ -0,0 +1,20 @@
+class Sfn::Topic < Sfn::Resource
+  attributes :subject, :style, :content, :reply_count, :follower_count, :company_id, :at_sfn
+  attribute :last_active_at, :type => Time
+  attribute :created_at, :type => Time
+  attribute :author, :type => Sfn::Person
+  
+  def path
+    "/topics/#{@id}"
+  end
+  
+  def setup_associations
+    has_many :replies, :url => "#{path}/replies"
+    has_many :people, :url => "#{path}/people"
+    has_many :products, :url => "#{path}/products"
+    has_many :tags, :url => "#{path}/tags"
+    
+    belongs_to :company
+  end
+
+end

data/lib/satisfaction/util.rb

@@ -0,0 +1,13 @@
+module Sfn::Util
+  def requestify(parameters, prefix=nil)
+    parameters.inject({}) do |results, kv|
+      if Hash === kv.last
+        results = results.merge(requestify(kv.last, "#{prefix}[#{kv.first}]"))
+      else
+        results["#{prefix}[#{kv.first}]"] = kv.last
+      end
+        
+      results
+    end
+  end
+end

data/lib/satisfaction/version.rb

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

data/lib/satisfaction.rb

@@ -0,0 +1,162 @@
+require 'satisfaction/external_dependencies'
+module Sfn
+end
+class Satisfaction
+  # ==================
+  # = Core Utilities =
+  # ==================
+  require 'satisfaction/util'
+  require 'satisfaction/has_satisfaction'
+  require 'satisfaction/associations'
+  require 'satisfaction/resource'
+  require 'satisfaction/loader'
+  require 'satisfaction/identity_map'
+  require 'satisfaction/search'
+  
+  
+  # =============
+  # = Resources =
+  # =============
+  
+  require 'satisfaction/company'
+  require 'satisfaction/person'
+  require 'satisfaction/topic'
+  require 'satisfaction/tag'
+  require 'satisfaction/product'
+  require 'satisfaction/reply'
+  
+  # =============
+  
+  include Associations
+  
+  attr_reader :options
+  attr_reader :loader
+  attr_reader :consumer
+  attr_reader :token
+  attr_reader :identity_map
+  attr_reader :search
+
+  
+  def initialize(options={})
+    @options = options.reverse_merge({
+      :root => "http://api.getsatisfaction.com", 
+      :autoload => false,
+      :request_token_url => 'http://getsatisfaction.com/api/request_token',
+      :access_token_url => 'http://getsatisfaction.com/api/access_token',
+      :authorize_url => 'http://getsatisfaction.com/api/authorize',
+    })
+    @loader = Sfn::Loader.new
+    @identity_map = Sfn::IdentityMap.new
+    @search = Sfn::Search.new(options[:root], @loader)
+    
+    has_many :companies, :url => '/companies'
+    has_many :people, :url => '/people'
+    has_many :topics, :url => '/topics'
+    has_many :replies, :url => '/replies'
+    has_many :tags, :url => '/tags'
+    has_many :products, :url => '/products'
+  end
+  
+  def satisfaction
+    self
+  end
+  
+  def me
+    me = satisfaction.identity_map.get_record(Me, 'me') do
+      Sfn::Me.new('me', satisfaction)
+    end
+    
+    if me.loaded?
+      me
+    else
+      me.load 
+    end
+  end
+  
+  def autoload?
+    options[:autoload]
+  end
+  
+  def set_basic_auth(user, password)
+    identity_map.expire_record(Me, 'me')
+    @user = user
+    @password = password
+  end
+  
+  def set_consumer(key, secret)
+    identity_map.expire_record(Me, 'me')
+    @consumer = OAuth::Consumer.new(key, secret)
+  end
+  
+  def set_token(token, secret)
+    identity_map.expire_record(Me, 'me')
+    @token = OAuth::Token.new(token, secret)
+  end
+  
+  def request_token
+    result, body = *@loader.get("#{options[:request_token_url]}", :force => true, :consumer => @consumer, :token => nil)
+    raise "Could not retrieve request token" unless result == :ok
+    response = CGI.parse(body)
+    OAuth::Token.new(response["oauth_token"], response["oauth_token_secret"])
+  end
+  
+  def authorize_url(token)
+    "#{options[:authorize_url]}?oauth_token=#{token.token}"
+  end
+  
+  def access_token(token)
+    result, body = *@loader.get("#{options[:access_token_url]}", :force => true, :consumer => @consumer, :token => token)
+    raise "Could not retrieve access token" unless result == :ok
+    response = CGI.parse(body)
+    OAuth::Token.new(response["oauth_token"], response["oauth_token_secret"])
+  end
+  
+  
+  def url(path, query_string={})
+    qs = query_string.map{|kv| URI.escape(kv.first.to_s) + "=" + URI.escape(kv.last.to_s)}.join("&")
+    URI.parse("#{@options[:root]}#{path}?#{qs}")
+  end
+  
+  def get(path, query_string={})
+    url = self.url(path, query_string)
+    
+    @loader.get(url, :consumer => @consumer, :token => @token, :user => @user, :password => @password)
+      
+  end
+  
+  def post(path, form={})
+    url = self.url(path)
+    @loader.post(url, 
+      :consumer => @consumer, 
+      :token => @token, 
+      :user => @user, 
+      :password => @password,
+      :form => form)
+  end
+  
+  def delete(path)
+    url = self.url(path)
+    @loader.post(url,
+      :consumer => @consumer, 
+      :token => @token, 
+      :user => @user, 
+      :password => @password,
+      :method => :delete)
+  end
+  
+  def put(path, form={})
+    url = self.url(path)
+    @loader.post(url, 
+      :consumer => @consumer, 
+      :token => @token, 
+      :user => @user, 
+      :password => @password,
+      :method => :put,
+      :form => form)
+  end
+  
+  private
+  def validate_options
+    raise ArgumentError, "You must specify a location for the API's service root" if options[:root].blank?
+  end
+end

data/spec/company_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "Company loader" do
+  it "should work" do
+    @satisfaction.set_consumer('lmwjv4kzwi27', 'fiei6iv61jnoukaq1aylwd8vcmnkafrs')
+    p @satisfaction.request_token
+  end
+end

data/spec/identity_map_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Identity Map" do
+  it "should work single instances" do
+    c1 = @satisfaction.companies.get(4)
+    c2 = @satisfaction.companies.get(4)
+    
+    c1.object_id.should == c2.object_id
+  end
+  
+  it "should load one if the other gets loaded" do
+    c1 = @satisfaction.companies.get(4)
+    c2 = @satisfaction.companies.get(4)
+    c2.should_not be_loaded
+    
+    c1.load
+  
+    c2.should be_loaded
+    c2.domain.should == 'satisfaction'
+  end
+  
+  it "should work with pages too" do
+    c1 = @satisfaction.companies.get(4)
+    c2 = @satisfaction.companies.page(1, :q => 'satisfaction').first
+    
+    c1.object_id.should == c2.object_id
+  end
+end

data/spec/search_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Searching" do
+  it "should not blow up" do
+    results = @satisfaction.search.for_likely_matches_to('Cyberdyne')
+  end
+  
+  it "should be a well-formed hash with default keys" do
+    results = @satisfaction.search.for_likely_matches_to('Cyberdyne')
+    results.should_not be_empty
+    results.class.should == Hash
+    results.keys.should include('products')
+    results.keys.should include('companies')
+    #raise results.inspect
+  end
+  
+  it "should put the results into a set of arrays keyed by category" do
+    results = @satisfaction.search.for_likely_matches_to('Cyberdyne')
+
+    c = results['companies']
+    c.class.should == Array
+    include('companies')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'spec'
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'satisfaction'
+
+Spec::Runner.configure do |config|
+  config.prepend_before(:each){ @satisfaction = Satisfaction.new(:root => 'http://api.getsatisfaction.com') }
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: pius-ruby-satisfaction
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Scott Fleckenstein
+- Josh Nichols
+- Pius Uzamere
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-10 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Ruby interface to Get Satisfaction
+email: scott@getsatisfaction.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- .gemified
+- .gitignore
+- CONTRIBUTORS.txt
+- License.txt
+- README.txt
+- Rakefile
+- VERSION
+- init.rb
+- lib/satisfaction.rb
+- lib/satisfaction/associations.rb
+- lib/satisfaction/cache/hash.rb
+- lib/satisfaction/cache/memcache.rb
+- lib/satisfaction/company.rb
+- lib/satisfaction/external_dependencies.rb
+- lib/satisfaction/has_satisfaction.rb
+- lib/satisfaction/identity_map.rb
+- lib/satisfaction/loader.rb
+- lib/satisfaction/person.rb
+- lib/satisfaction/product.rb
+- lib/satisfaction/reply.rb
+- lib/satisfaction/resource.rb
+- lib/satisfaction/resource/attributes.rb
+- lib/satisfaction/search.rb
+- lib/satisfaction/tag.rb
+- lib/satisfaction/topic.rb
+- lib/satisfaction/util.rb
+- lib/satisfaction/version.rb
+- spec/company_spec.rb
+- spec/identity_map_spec.rb
+- spec/search_spec.rb
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/pius/ruby-satisfaction
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Ruby interface to Get Satisfaction
+test_files: 
+- spec/company_spec.rb
+- spec/identity_map_spec.rb
+- spec/search_spec.rb
+- spec/spec_helper.rb