ruby-satisfaction 0.1.0

data/lib/satisfaction.rb

@@ -0,0 +1,145 @@
+require 'satisfaction/external_dependencies'
+
+class Satisfaction
+  # ==================
+  # = Core Utilities =
+  # ==================
+  require 'satisfaction/util'
+  require 'satisfaction/has_satisfaction'
+  require 'satisfaction/associations'
+  require 'satisfaction/resource'
+  require 'satisfaction/loader'
+  require 'satisfaction/identity_map'
+  
+  
+  # =============
+  # = 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
+
+  
+  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 = Satisfaction::Loader.new
+    @identity_map = Satisfaction::IdentityMap.new
+    
+    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 ||= Me.new('me', self)
+    @me.load
+    @me
+  end
+  
+  def autoload?
+    options[:autoload]
+  end
+  
+  def set_basic_auth(user, password)
+    @user = user
+    @password = password
+  end
+  
+  def set_consumer(key, secret)
+    @consumer = OAuth::Consumer.new(key, secret)
+  end
+  
+  def set_token(token, secret)
+    @token = OAuth::Token.new(token, secret)
+  end
+  
+  def request_token
+    response = CGI.parse(@loader.get("#{options[:request_token_url]}", :force => true, :consumer => @consumer, :token => nil))
+    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)
+    response = CGI.parse(@loader.get("#{options[:access_token_url]}", :force => true, :consumer => @consumer, :token => token))
+    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/lib/satisfaction/associations.rb

@@ -0,0 +1,20 @@
+module Associations
+  def has_many(resource, options={})
+    class_name = options[:class_name] || resource.to_s.classify
+    eval <<-EOS
+      def #{resource}
+        @#{resource} ||= ResourceCollection.new(#{class_name}, self.satisfaction, '#{options[:url]}')
+      end
+    EOS
+  end
+  
+  def belongs_to(resource, options={})
+    class_name = options[:class_name] || 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 Satisfaction::Loader::HashCache
+  def initialize
+    @cached_responses = {}
+  end
+  
+  def put(url, response)
+    return nil if response["ETag"].blank?
+    @cached_responses[url.to_s] = Satisfaction::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 Satisfaction::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] = 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 Company < 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 => '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 Satisfaction::HasSatisfaction
+  attr_reader :satisfaction
+  
+  def initialize(satisfaction)
+    @satisfaction = satisfaction
+  end
+  
+end

data/lib/satisfaction/identity_map.rb

@@ -0,0 +1,17 @@
+class Satisfaction::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
+end

data/lib/satisfaction/loader.rb

@@ -0,0 +1,105 @@
+require 'net/http'
+require 'uri'
+
+
+class Satisfaction::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})
+    @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, options)
+    response = execute(http, request)
+    
+    case response
+    when Net::HTTPNotModified
+      return cache_record.body
+    when Net::HTTPSuccess
+      cache.put(uri, response)
+      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))
+    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, 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, 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,25 @@
+class Person < 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 => 'Topic'
+  end
+end
+
+class Me < Person  
+  def path
+    "/me"
+  end
+  
+  def load
+    result = satisfaction.get("#{path}.json")    
+    self.attributes = JSON.parse(result)
+    self
+  end
+end

data/lib/satisfaction/product.rb

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

data/lib/satisfaction/resource.rb

@@ -0,0 +1,190 @@
+require 'forwardable'
+
+class Resource < Satisfaction::HasSatisfaction
+  require 'satisfaction/resource/attributes'
+  include ::Associations
+  include Attributes
+  attr_reader :id
+  include Satisfaction::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")    
+    self.attributes = JSON.parse(result)
+    self
+  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
+    "<#{self.class.name} #{attributes.map{|k,v| "#{k}: #{v}"}.join(' ') if !attributes.nil?}>"
+  end
+
+end
+
+class ResourceCollection < Satisfaction::HasSatisfaction
+  attr_reader :klass
+  attr_reader :path
+  include Satisfaction::Util
+  
+  def initialize(klass, satisfaction, path)
+    super satisfaction
+    @klass = klass
+    @path = path
+  end
+  
+  def page(number, options={})
+    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 Page < Satisfaction::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
+    
+    results = satisfaction.get("#{@path}.json", @options.merge(:page => @page))
+    json = JSON.parse(results)
+    @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
+  end
+end

data/lib/satisfaction/resource/attributes.rb

@@ -0,0 +1,67 @@
+module 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 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/tag.rb

@@ -0,0 +1,14 @@
+class Tag < 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 Topic < Resource
+  attributes :subject, :style, :content, :reply_count, :follower_count, :company_id
+  attribute :last_active_at, :type => Time
+  attribute :created_at, :type => Time
+  attribute :author, :type => 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 Satisfaction::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

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-satisfaction
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Scott Fleckenstein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: memcache-client
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: nullstyle@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/satisfaction
+- lib/satisfaction/associations.rb
+- lib/satisfaction/cache
+- 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
+- lib/satisfaction/resource/attributes.rb
+- lib/satisfaction/resource.rb
+- lib/satisfaction/tag.rb
+- lib/satisfaction/topic.rb
+- lib/satisfaction/util.rb
+- lib/satisfaction/version.rb
+- lib/satisfaction.rb
+has_rdoc: false
+homepage: http://nullstyle.com
+post_install_message: 
+rdoc_options: []
+
+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.0.1
+signing_key: 
+specification_version: 2
+summary: Helper gem for the getsatisfaction.com API
+test_files: []
+