hyperpublic 0.1.0

data/lib/hyperpublic/things.rb

@@ -0,0 +1,27 @@
+module Hyperpublic
+  class Things < Base
+    extend Forwardable
+    def_delegators :client, :get, :post, :post_multi, :put, :delete
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def find(params)
+      if params.is_a? String
+        perform_get("/things/#{params}")
+      else
+        q = Addressable::URI.new
+        q.query_values = stringify(params)
+        perform_get("/things?#{q.query}")
+      end
+    end
+
+    def create(options={})
+      perform_post("/things", :body => options)
+    end
+
+  end
+end

data/lib/hyperpublic/version.rb

@@ -0,0 +1,3 @@
+module Hyperpublic
+  VERSION = "0.1.2"
+end

data/lib/hyperpublic.rb

@@ -0,0 +1,148 @@
+require "forwardable"
+require "hashie"
+require "httparty"
+require "multi_json"
+require 'openssl'
+
+module OpenSSL
+  module SSL
+    remove_const :VERIFY_PEER
+  end
+end
+OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE
+
+module Hyperpublic
+  include HTTParty
+
+  class HyperpublicError < StandardError
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+      super
+    end
+  end
+
+  class Unauthorized  < HyperpublicError; end
+  class General       < HyperpublicError; end
+
+  class BadRequest    < StandardError; end
+  class Unavailable   < StandardError; end
+  class NotFound      < StandardError; end
+
+  def self.user_agent
+    @user_agent ||= 'Ruby Hyperpublic Gem'
+  end
+
+  def self.user_agent=(value)
+    @user_agent = value
+  end
+
+  def self.api_endpoint
+    @api_endpoint ||= "https://api.hyperpublic.com/api/v#{self.api_version}"
+  end
+
+  def self.api_endpoint=(value)
+    @api_endpoint = value
+  end
+
+  def self.api_version
+    @api_version ||= "1"
+  end
+
+  def self.api_version=(value)
+    @api_version = value
+  end
+
+  private
+
+  def self.perform_get(uri, options = {})
+    base_uri self.api_endpoint
+    make_friendly(get(uri, options))
+  end
+
+  def self.make_friendly(response)
+    raise_errors(response)
+    data = parse(response)
+    # Don't mash arrays of integers
+    if data && data.is_a?(Array) && data.first.is_a?(Integer)
+      data
+    else
+      mash(data)
+    end
+  end
+
+  def self.raise_errors(response)
+    case response.code.to_i
+      when 400
+        data = parse(response)
+        raise BadRequest.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 401
+        data = parse(response)
+        raise Unauthorized.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 403
+        data = parse(response)
+        raise General.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 404
+        data = parse(response)
+        raise NotFound, "(#{response.code}): #{response.message}" +
+                        (data ? " - " + data['error'] : "")
+      when 500..503
+        raise Unavailable, "(#{response.code}): #{response.message}"
+    end
+  end
+
+  def self.parse(response)
+    case response.body
+    when ''
+      nil
+    when 'true'
+      true
+    when 'false'
+      false
+    else
+      MultiJson.decode(response.body)
+    end
+  end
+
+  def self.mash(obj)
+    if obj.is_a?(Array)
+      obj.map{|item| Hashie::Mash.new(item)}
+    elsif obj.is_a?(Hash)
+      Hashie::Mash.new(obj)
+    else
+      obj
+    end
+  end
+end
+
+module Hashie
+  class Mash
+
+    # Converts all of the keys to strings, optionally formatting key name
+    def rubyify_keys!
+      keys.each{|k|
+        v = delete(k)
+        new_key = k.to_s.underscore
+        self[new_key] = v
+        v.rubyify_keys! if v.is_a?(Hash)
+        v.each{|p| p.rubyify_keys! if p.is_a?(Hash)} if v.is_a?(Array)
+      }
+      self
+    end
+
+  end
+end
+
+directory = File.expand_path(File.dirname(__FILE__))
+
+require File.join(directory, "hyperpublic", "oauth")
+require File.join(directory, "hyperpublic", "request")
+require File.join(directory, "hyperpublic", "base")
+require File.join(directory, "hyperpublic", "offers")
+require File.join(directory, "hyperpublic", "people")
+require File.join(directory, "hyperpublic", "all")
+require File.join(directory, "hyperpublic", "things")
+require File.join(directory, "hyperpublic", "places")
+require File.join(directory, "hyperpublic", "categories")
+require File.join(directory, "hyperpublic", "version")

data/spec/hyperpublic/base_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Hyperpublic::Base do
+  context "base" do
+    before do
+      @auth = Hyperpublic::OAuth.new("username", "password")
+      @hyperpublic = Hyperpublic::Base.new(@auth)
+    end
+
+    it "should delegate get to the client" do
+      @auth.should_receive(:get).with("/foo")
+      @hyperpublic.get("/foo")
+    end
+
+    it "should delegate post to the client" do
+      @auth.should_receive(:post).with("/foo", {:bar => "baz"}).and_return(nil)
+      @hyperpublic.post("/foo", {:bar => "baz"})
+    end
+
+  end
+end

data/spec/hyperpublic/people_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Hyperpublic::People do
+  context "base" do
+    before do
+      @auth = Hyperpublic::OAuth.new("username", "password")
+      @hp_people = Hyperpublic::People.new(@auth)
+    end
+
+    it "should be able to get person" do
+      stub_get(@auth, "people/1?",
+        '{"all_tags":[],"locations":[],"id":"1",
+          "image":{"src_thumb":"http://some_url",
+          "id":1,"src_large":"http://some_url"}}')
+      person = @hp_people.find("1")
+      person.id.should == "1"
+    end
+
+    it "should be able to get a list of people by ids" do
+      stub_get(@auth, "people?ids[0]=1&ids[1]=2", 
+        '[{"id":1}, {"id":2}]')
+      people = @hp_people.find({:ids => [1, 2]})
+      people.count.should == 2
+    end
+
+    it "should be able to get a list of people by tags" do
+      stub_get(@auth, "people?tags[0]=tag1&tags[1]=tag2", 
+        '[{"id":1}, {"id":2}]')
+      people = @hp_people.find({:tags => ["tag1", "tag2"]})
+      people.count.should == 2
+    end
+
+    it "should be able to get a list of people by location" do
+      stub_get(@auth, "people?location=10012", 
+        '[{"id":1}, {"id":2}]')
+      people = @hp_people.find({:location  => 10012})
+      people.count.should == 2
+    end
+
+    #TODO: finish this
+    it "should be able to create a user" do
+      stub_post(@auth, "people", '{"email":"etang@hyperpublic.com"}')
+      person = @hp_people.create({:email => "etang@hyperpublic.com", :image_url => "www.hyperpublic.com/image/2832.jpg"})
+      person.email.should == "etang@hyperpublic.com"
+    end
+
+  end
+end

data/spec/hyperpublic/places_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Hyperpublic::Places do
+  context "places" do
+    before do
+      @auth = Hyperpublic::OAuth.new("username", "password")
+      @hp_places = Hyperpublic::Places.new(@auth)
+    end
+
+    it "should be able to get a place" do
+      stub_get(@auth, "places/1?", '{"id":"1", "name":"hyperpublic"}')
+      place = @hp_places.find("1")
+      place.id.should == "1"
+    end
+
+    it "should be able to get a list of place by ids" do
+      stub_get(@auth, "places?ids[0]=1&ids[1]=2", '[{"id":1},{"id":2}]')
+      places = @hp_places.find(:ids=>[1,2])
+      places.count.should == 2
+    end
+
+    it "should be able to get a list of places by tags" do
+      stub_get(@auth, "places?tags[0]=tag1&tags[1]=tag2", '[{"id":1},{"id":2}]')
+      places = @hp_places.find(:tags=>["tag1", "tag2"])
+      places.count.should == 2
+    end
+
+    it "should be able to get a list of places by location" do
+      stub_get(@auth, "places?location=10012", '[{"id":1}, {"id":2}]')
+      places = @hp_places.find(:location => 10012)
+      places.count.should == 2
+    end
+
+    it "should be able create a place" do
+      stub_post(@auth, "places?", '{"user_id":1, "name":"hyperpublic"}')
+      place = @hp_places.create({:user_id => 1, :name => "hyperpublic"})
+      place.name.should == "hyperpublic"
+    end
+
+  end
+end

data/spec/hyperpublic/request_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Hyperpublic::Request do
+  context "new get request" do
+    before do
+      @client = mock('hyperpublic client')
+      @request = Hyperpublic::Request.new(@client, :get, '/people', {:query => {:tags => "tag1"}})
+    end
+
+    it "should have a client" do
+      @request.client.should == @client
+    end
+
+    it "should have method" do
+      @request.method == :get
+    end
+
+    it "should have path" do
+      @request.path.should == "/people"
+    end
+
+    it "should have options" do
+      @request.options[:query][:tags].should == "tag1"
+    end
+
+    it "should have uri" do
+      @request.uri.should == "/people?tags=tag1"
+    end
+
+    context "performing request for collection" do
+      before do
+        response = mock('response') do
+
+        end
+      end
+    end
+
+    #TODO:finish error test cases
+    context "error raising" do
+
+    end
+  end
+end

data/spec/hyperpublic/things_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Hyperpublic::Things do
+  context "things" do
+    before do
+      @auth = Hyperpublic::OAuth.new("client_id", "client_secret")
+      @hp_things = Hyperpublic::Things.new(@auth)
+    end
+
+    it "should be able to get a thing" do
+      stub_get(@auth, "things/1?", 
+        '{"id":"1", "label":"a thing"}')
+      thing = @hp_things.find("1")
+      thing.id.should == "1"
+    end
+
+    it "should be able to get a list of things by ids" do
+      stub_get(@auth, "things?ids[0]=1&ids[1]=2",
+        '[{"id":1},{"id":2}]')
+      things = @hp_things.find({:ids => [1,2]})
+      things.count.should == 2
+    end
+
+    it "should be able to get a list of things by tags" do
+      stub_get(@auth, "things?tags[0]=tag1&tags[1]=tag2", 
+        '[{"id":1}, {"id":2}]')
+      things = @hp_things.find({:tags => ["tag1", "tag2"]})
+      things.count.should == 2
+    end
+
+    it "should be able to get a list of things by location" do
+      stub_get(@auth, "things?location=10012", 
+        '[{"id":1}, {"id":2}]')
+      things = @hp_things.find({:location => 10012})
+      things.count.should == 2
+    end
+
+    it "should be able to create a thing" do
+      stub_post(@auth, "things?", '{"user_id":1, "title":"my fave"}')
+      person = @hp_things.create({:title=>"my fave", :image_url => "www.hyperpublic.com/image/2832.jpg"})
+      person.title.should == "my fave"
+    end
+
+  end
+end

data/spec/hyperpublic_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Hyperpublic do
+  describe ".user_agent" do
+    it "should default User Agent to 'Ruby Hyperpublic Gem'" do
+      Hyperpublic.user_agent.should == 'Ruby Hyperpublic Gem'
+    end
+  end
+
+  context 'when overriding the user agent' do
+    describe '.user_agent' do
+      it 'should be able to specify the User Agent' do
+        Hyperpublic.user_agent = 'My Hyperpublic Gem'
+        Hyperpublic.user_agent.should == 'My Hyperpublic Gem'
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+#$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+#$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "pathname"
+#require "shoulda"
+#require "mocha"
+require 'fakeweb'
+require 'hyperpublic'
+
+FakeWeb.allow_net_connect = false
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/spec/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+end
+
+def hyperpublic_url(auth, url, req)
+  url =~ /^http/ ? url : "https://api.hyperpublic.com/api/v1/#{(url[-1,1] == "?" || req != "get") ? url : url+'&' }" + ((req == "get") ? "client_id=#{auth.ctoken}&client_secret=#{auth.csecret}" : "")
+end
+
+def stub_get(auth, url, result, status=nil)
+  options = {:body => result}
+  options.merge!({:status => status}) unless status.nil?
+  FakeWeb.register_uri(:get, hyperpublic_url(auth, url, "get"), options)
+end
+
+def stub_post(auth, url, result)
+  FakeWeb.register_uri(:post, hyperpublic_url(auth, url, "post"), :body => result)
+end
+
+def stub_put(auth, url, result)
+  FakeWeb.register_uri(:put, hyperpublic_url(auth, url, "put"), :body => result)
+end
+
+def stub_delete(auth, url, result)
+  FakeWeb.register_uri(:delete, hyperpublic_url(auth, url, "delete"), :body => result)
+end
+