her 0.3.7 → 0.3.8

data/Guardfile

@@ -1,7 +0,0 @@
-require "guard/guard"
-
-guard "rspec", :cli => "--colour --format=documentation" do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/.+\.rb$}) { "spec" }
-  watch("spec/spec_helper.rb") { "spec" }
-end

data/MIDDLEWARE.md

@@ -1,183 +0,0 @@
-# Middleware
-
-Since Her relies on [Faraday](https://github.com/technoweenie/faraday) to send HTTP requests, you can choose the middleware used to handle requests and responses. Using the block in the `setup` call, you have access to Faraday’s `connection` object and are able to customize the middleware stack used on each request and response.
-
-## Authentication
-
-Her doesn’t support authentication by default. However, it’s easy to implement one with request middleware. Using the `connection` block, we can add it to the middleware stack.
-
-For example, to add a API token header to your requests in a Rails application, you would do something like this:
-
-```ruby
-# app/controllers/application_controller.rb
-class ApplicationController < ActionController::Base
-  around_filter :do_with_authenticated_user
-
-  def do_with_authenticated_user
-    Thread.current[:my_api_token] = session[:my_api_token]
-    begin
-      yield
-    ensure
-      Thread.current[:my_access_token] = nil
-    end
-  end
-end
-
-# lib/my_token_authentication.rb
-class MyTokenAuthentication < Faraday::Middleware
-  def initialize(app, options={})
-    @app = app
-  end
-
-  def call(env)
-    env[:request_headers]["X-API-Token"] = Thread.current[:my_api_token] if Thread.current[:my_api_token].present?
-    @app.call(env)
-  end
-end
-
-# config/initializers/her.rb
-require "lib/my_token_authentication"
-
-Her::API.setup :url => "https://api.example.com" do |connection|
-  connection.use MyTokenAuthentication
-  connection.use Faraday::Request::UrlEncoded
-  connection.use Her::Middleware::DefaultParseJSON
-  connection.use Faraday::Adapter::NetHttp
-end
-```
-
-Now, each HTTP request made by Her will have the `X-API-Token` header.
-
-## Parsing JSON data
-
-By default, Her handles JSON data. It expects the resource/collection data to be returned at the first level.
-
-```javascript
-// The response of GET /users/1
-{ "id" : 1, "name" : "Tobias Fünke" }
-
-// The response of GET /users
-[{ "id" : 1, "name" : "Tobias Fünke" }]
-```
-
-However, you can define your own parsing method using a response middleware. The middleware should set `env[:body]` to a hash with three keys: `data`, `errors` and `metadata`. The following code uses a custom middleware to parse the JSON data:
-
-```ruby
-# Expects responses like:
-#
-#     {
-#       "result": {
-#         "id": 1,
-#         "name": "Tobias Fünke"
-#       },
-#       "errors" => []
-#     }
-#
-class MyCustomParser < Faraday::Response::Middleware
-  def on_complete(env)
-    json = MultiJson.load(env[:body], :symbolize_keys => true)
-    env[:body] = {
-      :data => json[:result],
-      :errors => json[:errors],
-      :metadata => json[:metadata]
-    }
-  end
-end
-
-Her::API.setup :url => "https://api.example.com" do |connection|
-  connection.use Faraday::Request::UrlEncoded
-  connection.use MyCustomParser
-  connection.use Faraday::Adapter::NetHttp
-end
-```
-
-## OAuth
-
-Using the `faraday_middleware` and `simple_oauth` gems, it’s fairly easy to use OAuth authentication with Her.
-
-In your Gemfile:
-
-```ruby
-gem "her"
-gem "faraday_middleware"
-gem "simple_oauth"
-```
-
-In your Ruby code:
-
-```ruby
-# Create an application on `https://dev.twitter.com/apps` to set these values
-TWITTER_CREDENTIALS = {
-  :consumer_key => "",
-  :consumer_secret => "",
-  :token => "",
-  :token_secret => ""
-}
-
-Her::API.setup :url => "https://api.twitter.com/1/" do |connection|
-  connection.use FaradayMiddleware::OAuth, TWITTER_CREDENTIALS
-  connection.use Faraday::Request::UrlEncoded
-  connection.use Her::Middleware::DefaultParseJSON
-  connection.use Faraday::Adapter::NetHttp
-end
-
-class Tweet
-  include Her::Model
-end
-
-@tweets = Tweet.get("/statuses/home_timeline.json")
-```
-
-See the *Authentication* middleware section for an example of how to pass different credentials based on the current user.
-
-## Caching
-
-Again, using the `faraday_middleware` makes it very easy to cache requests and responses:
-
-In your Gemfile:
-
-```ruby
-gem "her"
-gem "faraday_middleware"
-```
-
-In your Ruby code:
-
-```ruby
-class MyCache < Hash
-  def read(key)
-    if cached = self[key]
-      Marshal.load(cached)
-    end
-  end
-
-  def write(key, data)
-    self[key] = Marshal.dump(data)
-  end
-
-  def fetch(key)
-    read(key) || yield.tap { |data| write(key, data) }
-  end
-end
-
-# A cache system must respond to `#write`, `#read` and `#fetch`.
-# We should be probably using something like Memcached here, not a global object
-$cache = MyCache.new
-
-Her::API.setup :url => "https://api.example.com" do |connection|
-  connection.use Faraday::Request::UrlEncoded
-  connection.use FaradayMiddleware::Caching, $cache
-  connection.use Her::Middleware::DefaultParseJSON
-  connection.use Faraday::Adapter::NetHttp
-end
-
-class User
-  include Her::Model
-end
-
-@user = User.find(1)
-# GET /users/1
-
-@user = User.find(1)
-# This request will be fetched from the cache
-```

data/TESTING.md

@@ -1,88 +0,0 @@
-# Testing Her models
-
-Suppose we have these two models bound to your API:
-
-```ruby
-# app/models/user.rb
-class User
-  include Her::Model
-  custom_get :popular
-end
-
-# app/models/post.rb
-class Post
-  include Her::Model
-  custom_get :recent, :archived
-end
-```
-
-In order to test them, we’ll have to stub the remote API requests. With [RSpec](https://github.com/rspec/rspec-core), we can do this like so:
-
-```ruby
-# spec/spec_helper.rb
-RSpec.configure do |config|
-  config.include(Module.new do
-    def stub_api_for(klass)
-      klass.uses_api (api = Her::API.new)
-
-      # Here, you would customize this for your own API (URL, middleware, etc)
-      # like you have done in your application’s initializer
-      api.setup :url => "http://api.example.com" do |connection|
-        connection.use Her::Middleware::FirstLevelParseJSON
-        connection.use Faraday::Request::UrlEncoded
-        connection.adapter(:test) { |s| yield(s) }
-      end
-    end
-  end)
-end
-```
-
-Then, in your tests, we can specify what (fake) HTTP requests will return:
-
-```ruby
-# spec/models/user.rb
-describe User do
-  before do
-    stub_api_for(User) do |stub|
-      stub.get("/users/popular") { |env| [200, {}, [{ :id => 1, :name => "Tobias Fünke" }, { :id => 2, :name => "Lindsay Fünke" }].to_json] }
-    end
-  end
-
-  describe :popular do
-    subject { User.popular }
-    its(:length) { should == 2 }
-    its(:errors) { should be_empty }
-  end
-end
-```
-
-We can redefine the API for a model as many times as we want, like for more complex tests:
-
-```ruby
-# spec/models/user.rb
-describe Post do
-  describe :recent do
-    before do
-      stub_api_for(Post) do |stub|
-        stub.get("/posts/recent") { |env| [200, {}, [{ :id => 1 }, { :id => 2 }].to_json] }
-      end
-    end
-
-    subject { Post.recent }
-    its(:length) { should == 2 }
-    its(:errors) { should be_empty }
-  end
-
-  describe :archived do
-    before do
-      stub_api_for(Post) do |stub|
-        stub.get("/posts/archived") { |env| [200, {}, [{ :id => 1 }, { :id => 2 }].to_json] }
-      end
-    end
-
-    subject { Post.archived }
-    its(:length) { should == 2 }
-    its(:errors) { should be_empty }
-  end
-end
-```