typhoid 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.DS_STORE
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/.rvmrc

@@ -0,0 +1,5 @@
+rvm --create ruby-1.9.3-p125@typhoid
+# Ensure that Bundler is installed, install it if it is not.
+if ! command -v bundle > /dev/null; then
+  gem install bundler
+fi

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+
+# Specify your gem's dependencies in typhoid.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    typhoid (0.0.1)
+      typhoeus
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    ffi (1.0.11)
+    json_pure (1.7.3)
+    mime-types (1.18)
+    rake (0.9.2.2)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    typhoeus (0.4.2)
+      ffi (~> 1.0)
+      mime-types (~> 1.18)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json_pure (>= 1.4.1)
+  rake
+  rspec
+  typhoid!

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Doug Rohde
+
+MIT License
+
+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.md

@@ -0,0 +1,3 @@
+# This Repository Has Moved
+
+No new commits will be made here. Visit [sportngin/typhoid](https://github.com/sportngin/typhoid) for the latest work on this project.

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:docs) do |t|
+    t.rspec_opts = ["--format doc"]
+  end
+end
+
+task :default => :spec

data/lib/typhoid/attributes.rb

@@ -0,0 +1,76 @@
+module Typhoid
+  module Attributes
+    def load_values(params = {})
+      @attributes = Hash[params.map { |key, value| [key.to_s, value] }]
+    end
+
+    def attributes
+      @attributes ||= {}
+      @attributes
+    end
+
+    def read_attribute(name)
+      attributes[name.to_s]
+    end
+    alias :[] :read_attribute
+
+    def after_build(response, exception = nil)
+      assign_request_error(exception) if !response.success? || !exception.nil?
+    end
+
+    def assign_request_error(exception = nil)
+      self.resource_exception = exception || StandardError.new("Could not retrieve data from remote service")
+    end
+    private :assign_request_error
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    protected
+
+    module ClassMethods
+      def field(*field_names)
+        raise ArgumentError, "Must specify at least one field" if field_names.length == 0
+        @auto_init_fields ||= []
+        field_names.each do |field_name|
+          define_accessor field_name
+          @auto_init_fields << field_name.to_sym
+        end
+      end
+
+      def define_accessor(field_name)
+        define_method field_name do
+          attributes[field_name.to_s]
+        end
+        define_method "#{field_name}=" do |new_value|
+          attributes[field_name.to_s] = new_value
+        end
+      end
+      private :define_accessor
+
+      def auto_init_fields
+        @auto_init_fields || []
+      end
+
+      def builder
+        Builder
+      end
+
+      def parser
+        Parser
+      end
+
+      def build(klass, response)
+        builder.call(klass, response)
+      end
+
+      def load_values(object, response)
+        object.tap { |obj|
+          obj.load_values(parser.call response.body)
+          obj.after_build response
+        }
+      end
+    end
+  end
+end

data/lib/typhoid/builder.rb

@@ -0,0 +1,58 @@
+module Typhoid
+  class Builder
+    attr_reader :klass
+    attr_reader :response
+    attr_reader :body
+    attr_reader :parsed_body
+    attr_reader :exception
+
+    def self.call(klass, response)
+      new(klass, response).build
+    end
+
+    def initialize(klass, response)
+      @klass = klass
+      @response = response
+      @body = response.body
+      begin
+        @parsed_body = parser.call body
+      rescue StandardError => e
+        @parsed_body = {}
+        @exception = e
+      end
+    end
+
+    def build
+      array? ? build_array : build_single
+    end
+
+    def build_from_klass(attributes)
+      klass.new(attributes).tap { |item|
+        item.after_build(response, exception) if item.respond_to? :after_build
+      }
+    end
+    private :build_from_klass
+
+    def array?
+      parsed_body.is_a?(Array)
+    end
+    private :array?
+
+    def build_array
+      parsed_body.collect { |single|
+        build_from_klass(single)
+      }
+    end
+    private :build_array
+
+    def build_single
+      build_from_klass parsed_body
+    end
+    private :build_single
+
+    def parser
+      klass.parser
+    end
+    private :parser
+  end
+end

data/lib/typhoid/multi.rb

@@ -0,0 +1,21 @@
+module Typhoid
+  module Multi
+    def remote_resources(hydra = nil)
+      request_queue = RequestQueue.new(self, hydra)
+      yield request_queue if block_given?
+
+      request_queue.run
+
+      request_queue.requests.each do |req|
+        parse_queued_response req
+      end
+    end
+
+    protected
+
+    def parse_queued_response(req)
+      varname = "@" + req.name.to_s
+      req.target.instance_variable_set varname.to_sym, Typhoid::Resource.build(req.klass, req.response)
+    end
+  end
+end

data/lib/typhoid/parser.rb

@@ -0,0 +1,52 @@
+module Typhoid
+  class Parser
+    attr_reader :json_string
+
+    def self.call(json_string)
+      new(json_string).parse
+    end
+
+    def initialize(json_string)
+      @json_string = json_string
+    end
+
+    def parse
+      parsed_body
+    end
+
+    def parsed_body
+      engine.call json_string
+    rescue
+      raise ReadError, json_string
+    end
+    private :parsed_body
+
+    def engine
+      JSON.method(:parse)
+    end
+    private :engine
+  end
+
+  class ReadError < StandardError
+    attr_reader :body
+    def initialize(body)
+      @body = body
+    end
+
+    def to_s
+      "Could not parse JSON body: #{cleaned_body}"
+    end
+
+    def cleaned_body
+      clean = body[0..10]
+      clean = clean + "..." if add_dots?
+      clean
+    end
+    private :cleaned_body
+
+    def add_dots?
+      body.length > 10
+    end
+    private :add_dots?
+  end
+end

data/lib/typhoid/queued_request.rb

@@ -0,0 +1,32 @@
+module Typhoid
+  class QueuedRequest
+    attr_accessor :name, :request, :target, :klass
+    attr_accessor :on_complete
+
+    def initialize(hydra, name, req, target)
+      self.name = name
+      self.request = Typhoeus::Request.new(req.request_uri, req.options)
+      self.klass = req.klass
+      self.target = target
+      hydra.queue(self.request)
+    end
+
+    def on_complete
+      self.request.on_complete do
+        yield self if block_given?
+      end
+    end
+
+    def status
+      self.request.handled_response.code
+    end
+
+    def response
+      self.request.handled_response
+    end
+
+    def klass
+      @klass
+    end
+  end
+end

data/lib/typhoid/request_builder.rb

@@ -0,0 +1,29 @@
+module Typhoid
+  class RequestBuilder
+    attr_accessor :klass
+    attr_writer :method
+
+    def initialize(klass, uri, options = {})
+      @uri = uri
+      @request_options = options
+      @klass = klass
+    end
+
+    def request_uri
+      @uri
+    end
+
+    def options
+      @request_options
+    end
+
+    def http_method
+      options[:method] || :get
+    end
+
+    def run
+      klass.run(self)
+    end
+  end
+end
+

data/lib/typhoid/request_queue.rb

@@ -0,0 +1,33 @@
+require 'typhoeus'
+
+module Typhoid
+  class RequestQueue
+    attr_reader :queue
+    attr_accessor :target
+
+    def initialize(target, hydra = nil)
+      @target = target
+      @hydra = hydra || Typhoeus::Hydra.new
+    end
+
+    def resource(name, req, &block)
+      @queue ||= []
+      @queue << QueuedRequest.new(@hydra, name, req, @target)
+      #@queue[name].on_complete &block if block != nil
+    end
+
+    def resource_with_target(name, req, target, &block)
+      @queue ||= []
+      @queue << QueuedRequest.new(@hydra, name, req, target)
+      #@queue[name].on_complete &block if block != nil
+    end
+
+    def requests
+      @queue ||= []
+    end
+
+    def run
+      @hydra.run
+    end
+  end
+end

data/lib/typhoid/resource.rb

@@ -0,0 +1,116 @@
+require 'cgi'
+require 'typhoid/uri'
+
+module Typhoid
+  class Resource
+    include Typhoid::Multi
+    include Typhoid::Attributes
+
+    class << self
+      attr_accessor :site, :path
+    end
+
+    attr_accessor :resource_exception
+
+    def self.build_request(uri, options = {})
+      Typhoid::RequestBuilder.new(self, uri, options)
+    end
+
+    def self.run(request)
+      method = request.http_method
+      build(request.klass, (Typhoeus::Request.send method, request.request_uri, request.options))
+    end
+
+    def self.uri_join(*paths)
+      Uri.new(*paths).to_s
+    end
+
+    # Get this request URI based on site and path, can attach
+    # more paths
+    def self.request_uri(*more_paths)
+      uri_join site, path, *more_paths
+    end
+
+    def initialize(params = {})
+      load_values(params)
+    end
+
+    def success?
+      !resource_exception
+    end
+
+    def save!(method = nil)
+      save method
+      raise resource_exception unless success?
+    end
+
+    def destroy!
+      destroy
+      raise resource_exception unless success?
+    end
+
+    def save(method = nil)
+      request_and_load do
+        Typhoeus::Request.send save_http_method(method), save_request.request_uri, save_request.options
+      end
+    end
+
+    def destroy
+      request_and_load do
+        Typhoeus::Request.delete(delete_request.request_uri, delete_request.options)
+      end
+    end
+
+    def save_request
+      (new_record?) ? create_request : update_request
+    end
+
+    def save_http_method(method = nil)
+      return method if method
+      (new_record?) ? :post : :put
+    end
+
+    # Request URI is either in the object we retrieveed initially, built from
+    # site + path + id, or fail to the regular class#request_uri
+    #
+    # Also, check that the server we're speaking to isn't hypermedia inclined so
+    # look at our attributes for a URI
+    def request_uri
+      attributes["uri"] || (new_record? ? self.class.request_uri : self.class.request_uri(id))
+    end
+
+    def request_and_load(&block)
+      self.resource_exception = nil
+      response = yield
+      self.class.load_values(self, response)
+      success?
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def new_record?
+      id.to_s.length < 1
+    end
+    alias new? new_record?
+
+    protected
+
+    def to_params
+      attributes
+    end
+
+    def create_request(method = :post)
+      Typhoid::RequestBuilder.new(self.class, request_uri, :body => to_params.to_json, :method => method, :headers => {"Content-Type" => 'application/json'})
+    end
+
+    def update_request(method = :put)
+      Typhoid::RequestBuilder.new(self.class, request_uri, :body => to_params.to_json, :method => method, :headers => {"Content-Type" => 'application/json'})
+    end
+
+    def delete_request(method = :delete)
+      Typhoid::RequestBuilder.new(self.class, request_uri, :method => method)
+    end
+  end
+end

data/lib/typhoid/uri.rb

@@ -0,0 +1,37 @@
+require 'uri'
+module Typhoid
+  class Uri
+    private
+    attr_writer :base
+    attr_writer :paths
+
+    public
+    attr_reader :base
+    attr_reader :paths
+
+    def initialize(*paths)
+      self.base = URI.parse paths.shift.to_s
+      self.paths = sanitize(base.path) + sanitize(paths)
+      base.path = ""
+      raise "Invalid Base on #uri_join: #{base}" unless base.scheme || base.host
+    end
+
+    def join(*more_paths)
+      full_path = (paths + sanitize(more_paths)).join "/"
+      base.clone.merge(full_path).to_s
+    end
+
+    def to_s
+      join
+    end
+
+    def sanitize(*need_sanitizing)
+      need_sanitizing.
+        flatten.
+        compact.
+        map { |p| p.to_s.split("/").compact.delete_if(&:empty?) }.
+        flatten
+    end
+    private :sanitize
+  end
+end

data/lib/typhoid/version.rb

@@ -0,0 +1,3 @@
+module Typhoid
+  VERSION = "0.0.1"
+end

data/lib/typhoid.rb

@@ -0,0 +1,10 @@
+require "typhoid/version"
+require 'typhoid/uri'
+require 'typhoid/parser'
+require 'typhoid/builder'
+require "typhoid/request_queue"
+require "typhoid/queued_request"
+require "typhoid/multi"
+require 'typhoid/attributes'
+require 'typhoid/resource'
+require 'typhoid/request_builder'

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'json'
+
+Dir["spec/support/**/*.rb"].each {|f| require "./#{f}"} 
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.color = true
+end

data/spec/support/controller.rb

@@ -0,0 +1,5 @@
+require 'typhoid'
+
+class Controller
+  include Typhoid::Multi
+end

data/spec/support/game.rb

@@ -0,0 +1,15 @@
+require 'typhoid'
+
+class Game < Typhoid::Resource
+  field :id
+  field :team_1_name
+  field :team_2_name
+  field :start_time
+
+  self.site = 'http://localhost:3000/'
+  self.path = 'games/'
+
+  def self.get_game
+    build_request("http://localhost:3000/games/1")
+  end
+end

data/spec/support/player_stat.rb

@@ -0,0 +1,10 @@
+require 'typhoid'
+
+class PlayerStat < Typhoid::Resource
+  field :player_name
+  field :goals
+
+  def self.get_stats
+    build_request("http://localhost:3000/stats/2")
+  end
+end

data/spec/typhoid/builder_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+module Typhoid
+  describe Builder do
+    let(:example_json) { <<-JSON
+      {
+          "metadata": {
+              "current_user": {
+                  "first_name": "Jon",
+                  "id": 1,
+                  "last_name": "Gilmore",
+                  "uri": "http://user-service.dev/users/1",
+                  "user_name": "admin"
+              }
+          },
+          "result": {
+              "first_name": "Jon",
+              "id": 15,
+              "last_name": "Phenow",
+              "type": "orphan",
+              "uri": "http://user-service.dev/personas/15",
+              "user": null
+          }
+      }
+    JSON
+    }
+
+    let(:example_array) { <<-JSON
+      [{"metadata": null }, {"metadata": null }]
+    JSON
+    }
+    let(:klass) { Resource }
+    let(:response) { double body: mocked_body, success?: mocked_success }
+    let(:mocked_body) { example_json }
+    let(:mocked_success) { true }
+    describe "class" do
+      subject { Builder }
+      describe "call" do
+        subject { Builder.call klass, response }
+        it { should be_a Resource }
+        its(:attributes) { should have_key "metadata" }
+        its(:attributes) { should have_key "result" }
+      end
+    end
+
+    describe "instance" do
+      subject { Builder.new klass, response }
+      describe "successful" do
+        describe "singular" do
+          it "calls expected building methods" do
+            klass.any_instance.should_receive(:after_build).once
+            subject.build.should be_a Resource
+          end
+        end
+
+        describe "array" do
+          let(:mocked_body) { example_array }
+          it "calls expected building methods" do
+            subject.build.should be_an Array
+          end
+        end
+      end
+
+      describe "unsuccessful" do
+        let(:mocked_success) { false }
+        subject { Builder.new(klass, response).build }
+        describe "singular" do
+          it { should be_a Resource }
+          its(:resource_exception) { should_not be_nil }
+          its(:attributes) { should have_key "metadata" }
+        end
+
+        describe "array" do
+          let(:mocked_body) { example_array }
+          subject { Builder.new(klass, response).build.first }
+
+          it { should be_a Resource }
+          its(:resource_exception) { should_not be_nil }
+          its(:attributes) { should have_key "metadata" }
+        end
+      end
+    end
+  end
+end

data/spec/typhoid/multi_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'json'
+
+
+describe Typhoid::Multi do
+  context "making multiple requests" do
+    before(:each) do
+      @fake_hydra = Typhoeus::Hydra.new
+      game = Typhoeus::Response.new(:code => 200, :headers => "", :body => {"team_1_name" => "Bears"}.to_json, :time => 0.03)
+      @fake_hydra.stub(:get, "http://localhost:3000/games/1").and_return(game)
+
+      stats = Typhoeus::Response.new(:code => 200, :headers => "", 
+                                     :body => [{'player_name' => 'Bob', 'goals' => 1}, {'player_name' => 'Mike', 'goals' => 1}].to_json, :time => 0.02)
+      @fake_hydra.stub(:get, "http://localhost:3000/stats/2").and_return(stats)
+    end
+
+    it "should assign the response to instance variables" do
+      controller = Controller.new
+      controller.remote_resources(@fake_hydra) do |req|
+        req.resource(:game, Game.get_game)
+        req.resource(:stats, PlayerStat.get_stats)
+      end
+      #games returns a single object
+      controller.instance_variable_get("@game").class.should eql Game
+      controller.instance_variable_get("@game").team_1_name.should eql "Bears"
+
+      #stats returns an array
+      controller.instance_variable_get("@stats").class.should eql Array
+      controller.instance_variable_get("@stats")[0].class.should eql PlayerStat
+      controller.instance_variable_get("@stats")[0].player_name.should eql 'Bob'
+    end
+  end
+end

data/spec/typhoid/parser_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Typhoid
+  describe Parser do
+    let(:example_json) { <<-JSON
+      {
+          "metadata": {
+              "current_user": {
+                  "first_name": "Jon",
+                  "id": 1,
+                  "last_name": "Gilmore",
+                  "uri": "http://user-service.dev/users/1",
+                  "user_name": "admin"
+              }
+          },
+          "result": {
+              "first_name": "Jon",
+              "id": 15,
+              "last_name": "Phenow",
+              "type": "orphan",
+              "uri": "http://user-service.dev/personas/15",
+              "user": null
+          }
+      }
+    JSON
+    }
+
+    let(:example_array) { <<-JSON
+      [{"metadata": null }, {"metadata": null }]
+    JSON
+    }
+
+    describe "class" do
+      subject { Parser }
+
+      describe "call" do
+        subject { Parser.call(example_json) }
+
+        it { should be_a Hash }
+        it "has an expected element" do
+          subject["result"]["first_name"].should == "Jon"
+        end
+      end
+    end
+
+    describe "instance" do
+      subject { Parser.new example_json }
+      describe "parse" do
+        it "looks like a hash" do
+          subject.parse.should be_a Hash
+        end
+
+        it "has an expected element" do
+          subject.parse["result"]["type"].should == "orphan"
+        end
+      end
+    end
+  end
+end

data/spec/typhoid/request_builder_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Typhoid::RequestBuilder do
+  context "a request builder object" do
+    it "should provide an http method by default" do
+      req = Typhoid::RequestBuilder.new(Game, 'http://localhost/')
+      req.http_method.should eql :get
+    end
+
+    it "should set http method from options" do
+      req = Typhoid::RequestBuilder.new(Game, 'http://localhost', :method => :post)
+      req.http_method.should eql :post
+    end
+  end
+end

data/spec/typhoid/resource_spec.rb

@@ -0,0 +1,143 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Typhoid::Resource do
+  it "synchronizes field with attribute" do
+    response_data = {"team_1_name" => 'Bears', "team_2_name" => 'Lions'}
+    game = Game.new(response_data)
+    game.team_1_name.should == 'Bears'
+    game.attributes["team_1_name"].should == 'Bears'
+    game.attributes["team_1_name"] = 'Da Bears'
+    game.attributes["team_1_name"].should == 'Da Bears'
+    game.team_1_name.should == 'Da Bears'
+
+    game.team_1_name = 'Orange'
+    game.team_1_name.should == 'Orange'
+    game.attributes["team_1_name"].should == 'Orange'
+  end
+
+  it "should have fields defined" do
+    game = Game.new
+    game.should respond_to(:team_1_name)
+  end
+
+  it "should populate defined attributes" do
+    response_data = {"team_1_name" => 'Bears', "team_2_name" => 'Lions'}
+    game = Game.new(response_data)
+    game.team_1_name.should eql 'Bears'
+    game.start_time.should be_nil
+  end
+
+  it "should populate attributes" do
+    game = Game.new({"team_1_name" => 'Bears', "team_2_name" => 'Lions'})
+    game.read_attribute(:team_1_name).should eql 'Bears'
+    game[:team_2_name].should eql 'Lions'
+  end
+
+  it "should return the request path" do
+    game = Game.new
+    game.request_uri.should eql "http://localhost:3000/games"
+  end
+
+  context "making a standalone request" do
+    after { hydra.clear_stubs }
+    let(:hydra) { Typhoeus::Hydra.hydra }
+    let(:game_response) { Typhoeus::Response.new(:code => 200, :headers => "", :body => {"team_1_name" => "Bears", "id" => "1"}.to_json) }
+    let(:failed_game_response) { Typhoeus::Response.new(:code => 404, :headers => "", :body => {}.to_json) }
+    it "should retrieve an object" do
+      hydra.stub(:get, "http://localhost:3000/games/1").and_return(game_response)
+
+      game = Game.get_game.run
+      game.class.should eql Game
+      game.team_1_name.should eql 'Bears'
+    end
+
+    it "raises error on save!" do
+      hydra.stub(:post, "http://localhost:3000/games").and_return(failed_game_response)
+
+      game = Game.new
+      expect { game.save! }.to raise_error
+    end
+
+    it "raises error on destroy!" do
+      hydra.stub(:delete, "http://localhost:3000/games/1").and_return(failed_game_response)
+
+      game = Game.new("id" => 1, "team_1_name" => 'Tigers')
+      expect { game.destroy! }.to raise_error
+    end
+
+    it "raises error on save!" do
+      hydra.stub(:post, "http://localhost:3000/games").and_return(game_response)
+
+      game = Game.new
+      expect { game.save! }.to_not raise_error
+    end
+
+    it "raises error on save!" do
+      hydra.stub(:delete, "http://localhost:3000/games/1").and_return(game_response)
+
+      game = Game.new("id" => 1, "team_1_name" => 'Tigers')
+      expect { game.destroy! }.to_not raise_error
+    end
+
+    it "should create an object" do
+      hydra.stub(:post, "http://localhost:3000/games").and_return(game_response)
+
+      game = Game.new
+      game.save
+
+      game.id.should == "1"
+      game.team_1_name.should == "Bears"
+    end
+
+    it "should update an object" do
+      update_response = Typhoeus::Response.new(:code => 200, :headers => "", :body => {"team_1_name" => "Bears", "id" => "1"}.to_json)
+      hydra.stub(:put, "http://localhost:3000/games/1").and_return(update_response)
+
+      game = Game.new("id" => 1, "team_1_name" => 'Tigers')
+      game.save
+
+      game.resource_exception.should be_nil
+      game.team_1_name.should == "Bears"
+    end
+
+    it "should delete an object" do
+      hydra.stub(:delete, "http://localhost:3000/games/1").and_return(game_response)
+
+      game = Game.new("id" => 1, "team_1_name" => 'Tigers')
+      game.destroy
+
+      game.resource_exception.should be nil
+
+    end
+
+    it "should be able to specify save http verb" do
+      update_response = Typhoeus::Response.new(:code => 200, :headers => "", :body => {"team_1_name" => "Bears", "id" => "1"}.to_json)
+      hydra.stub(:post, "http://localhost:3000/games/1").and_return(update_response)
+
+      game = Game.new("id" => 1, "team_1_name" => 'Tigers')
+      game.save(:post)
+
+      game.resource_exception.should be nil
+
+    end
+  end
+
+  context "handling bad requests" do
+    let(:fake_hydra) { Typhoeus::Hydra.new }
+    before do
+      bad_game = Typhoeus::Response.new(:code => 500, :headers => "", :body => "<htmlasdfasdfasdf")
+      fake_hydra.stub(:get, "http://localhost:3000/games/1").and_return(bad_game)
+    end
+
+    it "should assign an exception object on a bad request" do
+      controller = Controller.new
+      controller.remote_resources(fake_hydra) do |req|
+        req.resource(:game, Game.get_game)
+      end
+
+      bad_game = controller.instance_variable_get("@game")
+      bad_game.team_1_name.should be_nil
+      bad_game.resource_exception.class.should be_true
+    end
+  end
+end

data/spec/typhoid/typhoid_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Typhoid do
+end

data/spec/typhoid/uri_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Typhoid
+  describe "Uri" do
+    subject { Uri.new *uris }
+    let(:uris) { ["http://localhost/", "users"] }
+
+    its(:to_s) { should == "http://localhost/users" }
+    it "sets base" do
+      subject.base.to_s.should == "http://localhost"
+    end
+
+    it "sets path" do
+      subject.paths.should == ["users"]
+    end
+
+    it "appends paths" do
+      subject.join("/","/a/","b","/c","d/").should == "http://localhost/users/a/b/c/d"
+    end
+
+    it "when joining it doesn't change itself" do
+      expect {
+        subject.join("/","/a/","b","/c","d/").should == "http://localhost/users/a/b/c/d"
+      }.
+      to_not change { subject.to_s }
+    end
+  end
+end

data/typhoid.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/typhoid/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Doug Rohde"]
+  gem.email         = ["doug.rohde@tstmedia.com"]
+  gem.description   = %q{A lightweight ORM-like wrapper around Typhoeus}
+  gem.summary       = %q{A lightweight ORM-like wrapper around Typhoeus}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "typhoid"
+  gem.require_paths = ["lib"]
+  gem.version       = Typhoid::VERSION
+
+  gem.add_dependency 'typhoeus'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'json_pure', [">= 1.4.1"]
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: typhoid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Doug Rohde
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json_pure
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+description: A lightweight ORM-like wrapper around Typhoeus
+email:
+- doug.rohde@tstmedia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/typhoid.rb
+- lib/typhoid/attributes.rb
+- lib/typhoid/builder.rb
+- lib/typhoid/multi.rb
+- lib/typhoid/parser.rb
+- lib/typhoid/queued_request.rb
+- lib/typhoid/request_builder.rb
+- lib/typhoid/request_queue.rb
+- lib/typhoid/resource.rb
+- lib/typhoid/uri.rb
+- lib/typhoid/version.rb
+- spec/spec_helper.rb
+- spec/support/controller.rb
+- spec/support/game.rb
+- spec/support/player_stat.rb
+- spec/typhoid/builder_spec.rb
+- spec/typhoid/multi_spec.rb
+- spec/typhoid/parser_spec.rb
+- spec/typhoid/request_builder_spec.rb
+- spec/typhoid/resource_spec.rb
+- spec/typhoid/typhoid_spec.rb
+- spec/typhoid/uri_spec.rb
+- typhoid.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3289300841199421232
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3289300841199421232
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A lightweight ORM-like wrapper around Typhoeus
+test_files:
+- spec/spec_helper.rb
+- spec/support/controller.rb
+- spec/support/game.rb
+- spec/support/player_stat.rb
+- spec/typhoid/builder_spec.rb
+- spec/typhoid/multi_spec.rb
+- spec/typhoid/parser_spec.rb
+- spec/typhoid/request_builder_spec.rb
+- spec/typhoid/resource_spec.rb
+- spec/typhoid/typhoid_spec.rb
+- spec/typhoid/uri_spec.rb